playlist: Define playlist_CurrentInput(), that returns current playing input.
[vlc.git] / src / playlist / engine.c
1 /*****************************************************************************
2  * engine.c : Run the playlist and handle its control
3  *****************************************************************************
4  * Copyright (C) 1999-2008 the VideoLAN team
5  *
6  * Authors: Samuel Hocevar <sam@zoy.org>
7  *          ClĂ©ment Stenac <zorglub@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <assert.h>
29 #include <vlc_common.h>
30 #include <vlc_sout.h>
31 #include <vlc_playlist.h>
32 #include <vlc_interface.h>
33 #include "playlist_internal.h"
34 #include "stream_output/stream_output.h" /* sout_DeleteInstance */
35
36 /*****************************************************************************
37  * Local prototypes
38  *****************************************************************************/
39 static void VariablesInit( playlist_t *p_playlist );
40 static void playlist_Destructor( vlc_object_t * p_this );
41 static void playlist_Destructor( vlc_object_t * p_this );
42
43 static int RandomCallback( vlc_object_t *p_this, char const *psz_cmd,
44                            vlc_value_t oldval, vlc_value_t newval, void *a )
45 {
46     (void)psz_cmd; (void)oldval; (void)newval; (void)a;
47
48     ((playlist_t*)p_this)->b_reset_currently_playing = true;
49     playlist_Signal( ((playlist_t*)p_this) );
50     return VLC_SUCCESS;
51 }
52
53 /**
54  * Create playlist
55  *
56  * Create a playlist structure.
57  * \param p_parent the vlc object that is to be the parent of this playlist
58  * \return a pointer to the created playlist, or NULL on error
59  */
60 playlist_t * playlist_Create( vlc_object_t *p_parent )
61 {
62     static const char playlist_name[] = "playlist";
63     playlist_t *p_playlist;
64     bool b_save;
65
66     /* Allocate structure */
67     p_playlist = vlc_custom_create( p_parent, sizeof( *p_playlist ),
68                                     VLC_OBJECT_GENERIC, playlist_name );
69     if( !p_playlist )
70         return NULL;
71
72     TAB_INIT( p_playlist->i_sds, p_playlist->pp_sds );
73
74     libvlc_priv(p_parent->p_libvlc)->p_playlist = p_playlist;
75
76     VariablesInit( p_playlist );
77
78     /* Initialise data structures */
79     vlc_mutex_init( &p_playlist->gc_lock );
80     p_playlist->i_last_playlist_id = 0;
81     p_playlist->p_input = NULL;
82
83     p_playlist->gc_date = 0;
84     p_playlist->b_cant_sleep = false;
85
86     ARRAY_INIT( p_playlist->items );
87     ARRAY_INIT( p_playlist->all_items );
88     ARRAY_INIT( p_playlist->current );
89
90     p_playlist->i_current_index = 0;
91     p_playlist->b_reset_currently_playing = true;
92     p_playlist->last_rebuild_date = 0;
93
94     p_playlist->b_tree = var_CreateGetBool( p_playlist, "playlist-tree" );
95
96     p_playlist->b_doing_ml = false;
97
98     p_playlist->b_auto_preparse =
99                         var_CreateGetBool( p_playlist, "auto-preparse" ) ;
100
101     p_playlist->p_root_category = playlist_NodeCreate( p_playlist, NULL, NULL,
102                                     0, NULL );
103     p_playlist->p_root_onelevel = playlist_NodeCreate( p_playlist, NULL, NULL,
104                                     0, p_playlist->p_root_category->p_input );
105
106     if( !p_playlist->p_root_category || !p_playlist->p_root_onelevel )
107         return NULL;
108
109     /* Create playlist and media library */
110     playlist_NodesPairCreate( p_playlist, _( "Playlist" ),
111                             &p_playlist->p_local_category,
112                             &p_playlist->p_local_onelevel, false );
113
114     p_playlist->p_local_category->i_flags |= PLAYLIST_RO_FLAG;
115     p_playlist->p_local_onelevel->i_flags |= PLAYLIST_RO_FLAG;
116
117     if( !p_playlist->p_local_category || !p_playlist->p_local_onelevel ||
118         !p_playlist->p_local_category->p_input ||
119         !p_playlist->p_local_onelevel->p_input )
120         return NULL;
121
122     if( config_GetInt( p_playlist, "media-library") )
123     {
124         playlist_NodesPairCreate( p_playlist, _( "Media Library" ),
125                             &p_playlist->p_ml_category,
126                             &p_playlist->p_ml_onelevel, false );
127
128         if(!p_playlist->p_ml_category || !p_playlist->p_ml_onelevel)
129             return NULL;
130
131         p_playlist->p_ml_category->i_flags |= PLAYLIST_RO_FLAG;
132         p_playlist->p_ml_onelevel->i_flags |= PLAYLIST_RO_FLAG;
133     }
134     else
135     {
136         p_playlist->p_ml_category = p_playlist->p_ml_onelevel = NULL;
137     }
138
139     /* Initial status */
140     p_playlist->status.p_item = NULL;
141     p_playlist->status.p_node = p_playlist->p_local_onelevel;
142     p_playlist->request.b_request = false;
143     p_playlist->status.i_status = PLAYLIST_STOPPED;
144
145     p_playlist->i_sort = SORT_ID;
146     p_playlist->i_order = ORDER_NORMAL;
147
148
149     b_save = p_playlist->b_auto_preparse;
150     p_playlist->b_auto_preparse = false;
151     playlist_MLLoad( p_playlist );
152     p_playlist->b_auto_preparse = true;
153
154     vlc_object_set_destructor( p_playlist, playlist_Destructor );
155
156     return p_playlist;
157 }
158
159 /**
160  * Destroy playlist
161  *
162  * Destroy a playlist structure.
163  * \param p_playlist the playlist object
164  * \return nothing
165  */
166
167 static void playlist_Destructor( vlc_object_t * p_this )
168 {
169     playlist_t * p_playlist = (playlist_t *)p_this;
170
171     if( p_playlist->p_preparse )
172         vlc_object_release( p_playlist->p_preparse );
173
174     if( p_playlist->p_fetcher )
175         vlc_object_release( p_playlist->p_fetcher );
176 #ifndef NDEBUG
177     libvlc_priv (p_this->p_libvlc)->p_playlist = NULL; /* pl_Yield() will fail */
178 #endif
179 }
180
181 /* Destroy remaining objects */
182 static void ObjectGarbageCollector( playlist_t *p_playlist, bool b_force )
183 {
184     if( !b_force )
185     {
186         if( mdate() - p_playlist->gc_date < 1000000 )
187         {
188             p_playlist->b_cant_sleep = true;
189             return;
190         }
191         else if( p_playlist->gc_date == 0 )
192             return;
193     }
194
195     vlc_mutex_lock( &p_playlist->gc_lock );
196     p_playlist->b_cant_sleep = false;
197     vlc_mutex_unlock( &p_playlist->gc_lock );
198 }
199
200 /* Input Callback */
201 static void input_state_changed( const vlc_event_t * event, void * data )
202 {
203     (void)event;
204     playlist_t * p_playlist = data;
205     playlist_Signal( p_playlist );
206 }
207
208 /* Input Callback */
209 static void input_selected_stream_changed( const vlc_event_t * event, void * data )
210 {
211     (void)event;
212     playlist_t * p_playlist = data;
213     PL_LOCK;
214     p_playlist->gc_date = mdate();
215     vlc_object_signal_unlocked( p_playlist );
216     PL_UNLOCK;
217 }
218
219 /* Internals */
220 void playlist_release_current_input( playlist_t * p_playlist )
221 {
222     vlc_assert_locked( &(vlc_internals(p_playlist)->lock) );
223
224     if( !p_playlist->p_input ) return;
225
226     input_thread_t * p_input = p_playlist->p_input;
227     vlc_event_manager_t * p_em = input_get_event_manager( p_input );
228
229     vlc_event_detach( p_em, vlc_InputStateChanged,
230                       input_state_changed, p_playlist );
231     vlc_event_detach( p_em, vlc_InputSelectedStreamChanged,
232                       input_selected_stream_changed, p_playlist );
233     p_playlist->p_input = NULL;
234
235     /* Release the playlist lock, because we may get stuck
236      * in vlc_object_release() for some time. */
237     PL_UNLOCK;
238     vlc_object_release( p_input );
239     PL_LOCK;
240 }
241
242 void playlist_set_current_input(
243     playlist_t * p_playlist, input_thread_t * p_input )
244 {
245     vlc_assert_locked( &(vlc_internals(p_playlist)->lock) );
246
247     playlist_release_current_input( p_playlist );
248
249     if( p_input )
250     {
251         vlc_object_yield( p_input );
252         p_playlist->p_input = p_input;
253         vlc_event_manager_t * p_em = input_get_event_manager( p_input );
254         vlc_event_attach( p_em, vlc_InputStateChanged,
255                           input_state_changed, p_playlist );
256         vlc_event_attach( p_em, vlc_InputSelectedStreamChanged,
257                           input_selected_stream_changed, p_playlist );
258     }
259 }
260
261 /** Get current playing input.
262  */
263 input_thread_t * playlist_CurrentInput( playlist_t * p_playlist )
264 {
265     input_thread_t * p_input;
266     PL_LOCK;
267     p_input = p_playlist->p_input;
268     if( p_input ) vlc_object_yield( p_input );
269     PL_UNLOCK;
270     return p_input;
271 }
272
273
274 /**
275  * @}
276  */
277
278 /**
279  * Main loop
280  *
281  * Main loop for the playlist
282  * \param p_playlist the playlist object
283  * \return nothing
284  */
285 void playlist_MainLoop( playlist_t *p_playlist )
286 {
287     playlist_item_t *p_item = NULL;
288     bool b_playexit = var_GetBool( p_playlist, "play-and-exit" );
289     PL_LOCK;
290
291     if( p_playlist->b_reset_currently_playing &&
292         mdate() - p_playlist->last_rebuild_date > 30000 ) // 30 ms
293     {
294         ResetCurrentlyPlaying( p_playlist, var_GetBool( p_playlist, "random" ),
295                              p_playlist->status.p_item );
296         p_playlist->last_rebuild_date = mdate();
297     }
298
299 check_input:
300     /* If there is an input, check that it doesn't need to die. */
301     if( p_playlist->p_input )
302     {
303         if( p_playlist->request.b_request && !p_playlist->p_input->b_die )
304         {
305             PL_DEBUG( "incoming request - stopping current input" );
306             input_StopThread( p_playlist->p_input );
307         }
308
309         /* This input is dead. Remove it ! */
310         if( p_playlist->p_input->b_dead )
311         {
312             int i_activity;
313             input_thread_t *p_input;
314             sout_instance_t **pp_sout =
315                 &libvlc_priv(p_playlist->p_libvlc)->p_sout;
316
317             PL_DEBUG( "dead input" );
318
319             p_input = p_playlist->p_input;
320
321             assert( *pp_sout == NULL );
322             if( var_CreateGetBool( p_input, "sout-keep" ) )
323                 *pp_sout = input_DetachSout( p_input );
324
325             /* Destroy input */
326             playlist_release_current_input( p_playlist );
327
328             p_playlist->gc_date = mdate();
329             p_playlist->b_cant_sleep = true;
330
331             if( p_playlist->status.p_item->i_flags
332                 & PLAYLIST_REMOVE_FLAG )
333             {
334                  PL_DEBUG( "%s was marked for deletion, deleting",
335                                  PLI_NAME( p_playlist->status.p_item  ) );
336                  playlist_ItemDelete( p_playlist->status.p_item );
337                  if( p_playlist->request.p_item == p_playlist->status.p_item )
338                      p_playlist->request.p_item = NULL;
339                  p_playlist->status.p_item = NULL;
340             }
341
342             i_activity= var_GetInteger( p_playlist, "activity" );
343             var_SetInteger( p_playlist, "activity", i_activity -
344                             DEFAULT_INPUT_ACTIVITY );
345
346             goto check_input;
347         }
348         /* This input is dying, let it do */
349         else if( p_playlist->p_input->b_die )
350         {
351             PL_DEBUG( "dying input" );
352             PL_UNLOCK;
353             msleep( INTF_IDLE_SLEEP );
354             PL_LOCK;
355             goto check_input;
356         }
357         /* This input has finished, ask it to die ! */
358         else if( p_playlist->p_input->b_error
359                   || p_playlist->p_input->b_eof )
360         {
361             PL_DEBUG( "finished input" );
362             input_StopThread( p_playlist->p_input );
363             /* No need to wait here, we'll wait in the p_input->b_die case */
364             goto check_input;
365         }
366         else if( p_playlist->p_input->i_state != INIT_S )
367         {
368             PL_UNLOCK;
369             ObjectGarbageCollector( p_playlist, false );
370             PL_LOCK;
371         }
372     }
373     else
374     {
375         /* No input. Several cases
376          *  - No request, running status -> start new item
377          *  - No request, stopped status -> collect garbage
378          *  - Request, running requested -> start new item
379          *  - Request, stopped requested -> collect garbage
380         */
381         int i_status = p_playlist->request.b_request ?
382             p_playlist->request.i_status : p_playlist->status.i_status;
383         if( i_status != PLAYLIST_STOPPED )
384         {
385             msg_Dbg( p_playlist, "starting new item" );
386             p_item = playlist_NextItem( p_playlist );
387
388             if( p_item == NULL )
389             {
390                 msg_Dbg( p_playlist, "nothing to play" );
391                 p_playlist->status.i_status = PLAYLIST_STOPPED;
392                 PL_UNLOCK;
393
394                 if( b_playexit == true )
395                 {
396                     msg_Info( p_playlist, "end of playlist, exiting" );
397                     vlc_object_kill( p_playlist->p_libvlc );
398                 }
399                 ObjectGarbageCollector( p_playlist, true );
400                 return;
401              }
402              playlist_PlayItem( p_playlist, p_item );
403          }
404          else
405          {
406             const bool b_gc_forced = p_playlist->status.i_status != PLAYLIST_STOPPED;
407
408             p_playlist->status.i_status = PLAYLIST_STOPPED;
409             if( p_playlist->status.p_item &&
410                 p_playlist->status.p_item->i_flags & PLAYLIST_REMOVE_FLAG )
411             {
412                 PL_DEBUG( "deleting item marked for deletion" );
413                 playlist_ItemDelete( p_playlist->status.p_item );
414                 p_playlist->status.p_item = NULL;
415             }
416
417             /* Collect garbage */
418             PL_UNLOCK;
419             ObjectGarbageCollector( p_playlist, b_gc_forced );
420             PL_LOCK;
421         }
422     }
423     PL_UNLOCK;
424 }
425
426 /**
427  * Last loop
428  *
429  * The playlist is dying so do the last loop
430  * \param p_playlist the playlist object
431  * \return nothing
432 */
433 void playlist_LastLoop( playlist_t *p_playlist )
434 {
435     /* If there is an input, kill it */
436     while( 1 )
437     {
438         PL_LOCK;
439         if( p_playlist->p_input == NULL )
440         {
441             PL_UNLOCK;
442             break;
443         }
444
445         if( p_playlist->p_input->b_dead )
446         {
447             /* remove input */
448             playlist_release_current_input( p_playlist );
449
450             /* sout-keep: no need to anything here.
451              * The last input will destroy its sout, if any, by itself */
452
453             PL_UNLOCK;
454             continue;
455         }
456         else if( p_playlist->p_input->b_die )
457         {
458             /* This input is dying, leave it alone */
459             ;
460         }
461         else if( p_playlist->p_input->b_error || p_playlist->p_input->b_eof )
462         {
463             input_StopThread( p_playlist->p_input );
464             PL_UNLOCK;
465             continue;
466         }
467         else
468         {
469             p_playlist->p_input->b_eof = 1;
470         }
471         PL_UNLOCK;
472
473         msleep( INTF_IDLE_SLEEP );
474     }
475
476 #ifdef ENABLE_SOUT
477     /* close the remaining sout-keep (if there was no input atm) */
478     sout_instance_t *p_sout = libvlc_priv (p_playlist->p_libvlc)->p_sout;
479     if (p_sout)
480         sout_DeleteInstance( p_sout );
481 #endif
482
483     /* Core should have terminated all SDs before the playlist */
484     /* TODO: It fails to do so when not playing anything -- Courmisch */
485     playlist_ServicesDiscoveryKillAll( p_playlist );
486     playlist_MLDump( p_playlist );
487
488     PL_LOCK;
489     FOREACH_ARRAY( playlist_item_t *p_del, p_playlist->all_items )
490         free( p_del->pp_children );
491         vlc_gc_decref( p_del->p_input );
492         free( p_del );
493     FOREACH_END();
494     ARRAY_RESET( p_playlist->all_items );
495
496     ARRAY_RESET( p_playlist->items );
497     ARRAY_RESET( p_playlist->current );
498
499     PL_UNLOCK;
500 }
501
502 /**
503  * Preparse loop
504  *
505  * Main loop for preparser queue
506  * \param p_obj items to preparse
507  * \return nothing
508  */
509 void playlist_PreparseLoop( playlist_preparse_t *p_obj )
510 {
511     playlist_t *p_playlist = (playlist_t *)p_obj->p_parent;
512     input_item_t *p_current;
513     int i_activity;
514
515     vlc_object_lock( p_obj );
516
517     while( vlc_object_alive( p_obj ) )
518     {
519         if( p_obj->i_waiting == 0 )
520         {
521             vlc_object_wait( p_obj );
522             continue;
523         }
524
525         p_current = p_obj->pp_waiting[0];
526         REMOVE_ELEM( p_obj->pp_waiting, p_obj->i_waiting, 0 );
527         vlc_object_unlock( p_obj );
528
529         PL_LOCK;
530         if( p_current )
531         {
532             if( p_current->i_type == ITEM_TYPE_FILE )
533             {
534                 stats_TimerStart( p_playlist, "Preparse run",
535                                   STATS_TIMER_PREPARSE );
536                 /* Do not preparse if it is already done (like by playing it) */
537                 if( !input_item_IsPreparsed( p_current ) )
538                 {
539                     PL_UNLOCK;
540                     input_Preparse( p_playlist, p_current );
541                     PL_LOCK;
542                 }
543                 stats_TimerStop( p_playlist, STATS_TIMER_PREPARSE );
544                 PL_UNLOCK;
545                 input_item_SetPreparsed( p_current, true );
546                 var_SetInteger( p_playlist, "item-change", p_current->i_id );
547                 PL_LOCK;
548             }
549             /* If we haven't retrieved enough meta, add to secondary queue
550              * which will run the "meta fetchers".
551              * This only checks for meta, not for art
552              * \todo don't do this for things we won't get meta for, like vids
553              */
554             char *psz_arturl = input_item_GetArtURL( p_current );
555             char *psz_name = input_item_GetName( p_current );
556             if( p_playlist->p_fetcher->i_art_policy == ALBUM_ART_ALL &&
557                         ( !psz_arturl || strncmp( psz_arturl, "file://", 7 ) ) )
558             {
559                 PL_DEBUG("meta ok for %s, need to fetch art", psz_name );
560                 vlc_object_lock( p_playlist->p_fetcher );
561                 INSERT_ELEM( p_playlist->p_fetcher->pp_waiting,
562                              p_playlist->p_fetcher->i_waiting,
563                              p_playlist->p_fetcher->i_waiting, p_current);
564                 vlc_object_signal_unlocked( p_playlist->p_fetcher );
565                 vlc_object_unlock( p_playlist->p_fetcher );
566             }
567             else
568             {
569                 PL_DEBUG( "no fetch required for %s (art currently %s)",
570                           psz_name, psz_arturl );
571                 vlc_gc_decref( p_current );
572             }
573             free( psz_name );
574             free( psz_arturl );
575             PL_UNLOCK;
576         }
577         else
578             PL_UNLOCK;
579
580         vlc_object_lock( p_obj );
581         i_activity = var_GetInteger( p_playlist, "activity" );
582         if( i_activity < 0 ) i_activity = 0;
583         vlc_object_unlock( p_obj );
584         /* Sleep at least 1ms */
585         msleep( (i_activity+1) * 1000 );
586         vlc_object_lock( p_obj );
587     }
588     vlc_object_unlock( p_obj );
589 }
590
591 /**
592  * Fetcher loop
593  *
594  * Main loop for secondary preparser queue
595  * \param p_obj items to preparse
596  * \return nothing
597  */
598 void playlist_FetcherLoop( playlist_fetcher_t *p_obj )
599 {
600     playlist_t *p_playlist = (playlist_t *)p_obj->p_parent;
601     input_item_t *p_item;
602     int i_activity;
603
604     vlc_object_lock( p_obj );
605
606     while( vlc_object_alive( p_obj ) )
607     {
608         if( p_obj->i_waiting == 0 )
609         {
610             vlc_object_wait( p_obj );
611             continue;
612         }
613
614         p_item = p_obj->pp_waiting[0];
615         REMOVE_ELEM( p_obj->pp_waiting, p_obj->i_waiting, 0 );
616         vlc_object_unlock( p_obj );
617         if( p_item )
618         {
619             int i_ret;
620
621             /* Check if it is not yet preparsed and if so wait for it (at most 0.5s)
622              * (This can happen if we fetch art on play)
623              * FIXME this doesn't work if we need to fetch meta before art ... */
624             for( i_ret = 0; i_ret < 10 && !input_item_IsPreparsed( p_item ); i_ret++ )
625             {
626                 bool b_break;
627                 PL_LOCK;
628                 b_break = ( !p_playlist->p_input || input_GetItem(p_playlist->p_input) != p_item  ||
629                             p_playlist->p_input->b_die || p_playlist->p_input->b_eof || p_playlist->p_input->b_error );
630                 PL_UNLOCK;
631                 if( b_break )
632                     break;
633                 msleep( 50000 );
634             }
635
636             i_ret = input_ArtFind( p_playlist, p_item );
637             if( i_ret == 1 )
638             {
639                 PL_DEBUG( "downloading art for %s", p_item->psz_name );
640                 if( input_DownloadAndCacheArt( p_playlist, p_item ) )
641                     input_item_SetArtNotFound( p_item, true );
642                 else {
643                     input_item_SetArtFetched( p_item, true );
644                     var_SetInteger( p_playlist, "item-change",
645                                     p_item->i_id );
646                 }
647             }
648             else if( i_ret == 0 ) /* Was in cache */
649             {
650                 PL_DEBUG( "found art for %s in cache", p_item->psz_name );
651                 input_item_SetArtFetched( p_item, true );
652                 var_SetInteger( p_playlist, "item-change", p_item->i_id );
653             }
654             else
655             {
656                 PL_DEBUG( "art not found for %s", p_item->psz_name );
657                 input_item_SetArtNotFound( p_item, true );
658             }
659             vlc_gc_decref( p_item );
660         }
661         vlc_object_lock( p_obj );
662         i_activity = var_GetInteger( p_playlist, "activity" );
663         if( i_activity < 0 ) i_activity = 0;
664         vlc_object_unlock( p_obj );
665         /* Sleep at least 1ms */
666         msleep( (i_activity+1) * 1000 );
667         vlc_object_lock( p_obj );
668     }
669     vlc_object_unlock( p_obj );
670 }
671
672 static void VariablesInit( playlist_t *p_playlist )
673 {
674     vlc_value_t val;
675     /* These variables control updates */
676     var_Create( p_playlist, "intf-change", VLC_VAR_BOOL );
677     val.b_bool = true;
678     var_Set( p_playlist, "intf-change", val );
679
680     var_Create( p_playlist, "item-change", VLC_VAR_INTEGER );
681     val.i_int = -1;
682     var_Set( p_playlist, "item-change", val );
683
684     var_Create( p_playlist, "item-deleted", VLC_VAR_INTEGER );
685     val.i_int = -1;
686     var_Set( p_playlist, "item-deleted", val );
687
688     var_Create( p_playlist, "item-append", VLC_VAR_ADDRESS );
689
690     var_Create( p_playlist, "playlist-current", VLC_VAR_INTEGER );
691     val.i_int = -1;
692     var_Set( p_playlist, "playlist-current", val );
693
694     var_Create( p_playlist, "activity", VLC_VAR_INTEGER );
695     var_SetInteger( p_playlist, "activity", 0 );
696
697     /* Variables to control playback */
698     var_CreateGetBool( p_playlist, "play-and-stop" );
699     var_CreateGetBool( p_playlist, "play-and-exit" );
700     var_CreateGetBool( p_playlist, "random" );
701     var_CreateGetBool( p_playlist, "repeat" );
702     var_CreateGetBool( p_playlist, "loop" );
703
704     var_AddCallback( p_playlist, "random", RandomCallback, NULL );
705 }