playlist: Move more members as private.
[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 <stddef.h>
29 #include <assert.h>
30 #include <vlc_common.h>
31 #include <vlc_sout.h>
32 #include <vlc_playlist.h>
33 #include <vlc_interface.h>
34 #include "playlist_internal.h"
35 #include "stream_output/stream_output.h" /* sout_DeleteInstance */
36
37 /*****************************************************************************
38  * Local prototypes
39  *****************************************************************************/
40 static void VariablesInit( playlist_t *p_playlist );
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     playlist_private_t *p;
65     bool b_save;
66
67     /* Allocate structure */
68     p = vlc_custom_create( p_parent, sizeof( *p ),
69                            VLC_OBJECT_GENERIC, playlist_name );
70     if( !p )
71         return NULL;
72
73     assert( offsetof( playlist_private_t, public_data ) == 0 );
74     p_playlist = &p->public_data;
75     TAB_INIT( pl_priv(p_playlist)->i_sds, pl_priv(p_playlist)->pp_sds );
76
77     libvlc_priv(p_parent->p_libvlc)->p_playlist = p_playlist;
78
79     VariablesInit( p_playlist );
80
81     /* Initialise data structures */
82     p_playlist->i_last_playlist_id = 0;
83     pl_priv(p_playlist)->p_input = NULL;
84
85     p_playlist->gc_date = 0;
86     p_playlist->b_cant_sleep = false;
87
88     ARRAY_INIT( p_playlist->items );
89     ARRAY_INIT( p_playlist->all_items );
90     ARRAY_INIT( p_playlist->items_to_delete );
91     ARRAY_INIT( p_playlist->current );
92
93     p_playlist->i_current_index = 0;
94     p_playlist->b_reset_currently_playing = true;
95     p_playlist->last_rebuild_date = 0;
96
97     p_playlist->b_tree = var_CreateGetBool( p_playlist, "playlist-tree" );
98
99     p_playlist->b_doing_ml = false;
100
101     p_playlist->b_auto_preparse =
102                         var_CreateGetBool( p_playlist, "auto-preparse" ) ;
103
104     PL_LOCK; /* playlist_NodeCreate will check for it */
105     p_playlist->p_root_category = playlist_NodeCreate( p_playlist, NULL, NULL,
106                                     0, NULL );
107     p_playlist->p_root_onelevel = playlist_NodeCreate( p_playlist, NULL, NULL,
108                                     0, p_playlist->p_root_category->p_input );
109     PL_UNLOCK;
110
111     if( !p_playlist->p_root_category || !p_playlist->p_root_onelevel )
112         return NULL;
113
114     /* Create playlist and media library */
115     PL_LOCK; /* playlist_NodesPairCreate will check for it */
116     playlist_NodesPairCreate( p_playlist, _( "Playlist" ),
117                             &p_playlist->p_local_category,
118                             &p_playlist->p_local_onelevel, false );
119     PL_UNLOCK;
120
121     p_playlist->p_local_category->i_flags |= PLAYLIST_RO_FLAG;
122     p_playlist->p_local_onelevel->i_flags |= PLAYLIST_RO_FLAG;
123
124     if( !p_playlist->p_local_category || !p_playlist->p_local_onelevel ||
125         !p_playlist->p_local_category->p_input ||
126         !p_playlist->p_local_onelevel->p_input )
127         return NULL;
128
129     if( config_GetInt( p_playlist, "media-library") )
130     {
131         PL_LOCK; /* playlist_NodesPairCreate will check for it */
132         playlist_NodesPairCreate( p_playlist, _( "Media Library" ),
133                             &p_playlist->p_ml_category,
134                             &p_playlist->p_ml_onelevel, false );
135         PL_UNLOCK;
136
137         if(!p_playlist->p_ml_category || !p_playlist->p_ml_onelevel)
138             return NULL;
139
140         p_playlist->p_ml_category->i_flags |= PLAYLIST_RO_FLAG;
141         p_playlist->p_ml_onelevel->i_flags |= PLAYLIST_RO_FLAG;
142     }
143     else
144     {
145         p_playlist->p_ml_category = p_playlist->p_ml_onelevel = NULL;
146     }
147
148     /* Initial status */
149     pl_priv(p_playlist)->status.p_item = NULL;
150     pl_priv(p_playlist)->status.p_node = p_playlist->p_local_onelevel;
151     pl_priv(p_playlist)->request.b_request = false;
152     pl_priv(p_playlist)->status.i_status = PLAYLIST_STOPPED;
153
154     p_playlist->i_sort = SORT_ID;
155     p_playlist->i_order = ORDER_NORMAL;
156
157
158     b_save = p_playlist->b_auto_preparse;
159     p_playlist->b_auto_preparse = false;
160     playlist_MLLoad( p_playlist );
161     p_playlist->b_auto_preparse = true;
162
163     vlc_object_set_destructor( p_playlist, playlist_Destructor );
164
165     return p_playlist;
166 }
167
168 /**
169  * Destroy playlist
170  *
171  * Destroy a playlist structure.
172  * \param p_playlist the playlist object
173  * \return nothing
174  */
175
176 static void playlist_Destructor( vlc_object_t * p_this )
177 {
178     playlist_t * p_playlist = (playlist_t *)p_this;
179
180     /* Destroy the item preparser */
181     playlist_preparse_t *p_preparse = &pl_priv(p_playlist)->preparse;
182     if (p_preparse->up)
183     {
184         vlc_cancel (p_preparse->thread);
185         vlc_join (p_preparse->thread, NULL);
186     }
187     while (p_preparse->i_waiting > 0)
188     {   /* Any left-over unparsed item? */
189         vlc_gc_decref (p_preparse->pp_waiting[0]);
190         REMOVE_ELEM (p_preparse->pp_waiting, p_preparse->i_waiting, 0);
191     }
192     vlc_cond_destroy (&p_preparse->wait);
193     vlc_mutex_destroy (&p_preparse->lock);
194
195     /* Destroy the item meta-infos fetcher */
196     playlist_fetcher_t *p_fetcher = &pl_priv(p_playlist)->fetcher;
197     if (p_fetcher->up)
198     {
199         vlc_cancel (p_fetcher->thread);
200         vlc_join (p_fetcher->thread, NULL);
201     }
202     while (p_fetcher->i_waiting > 0)
203     {   /* Any left-over unparsed item? */
204         vlc_gc_decref (p_fetcher->pp_waiting[0]);
205         REMOVE_ELEM (p_fetcher->pp_waiting, p_fetcher->i_waiting, 0);
206     }
207     vlc_cond_destroy (&p_fetcher->wait);
208     vlc_mutex_destroy (&p_fetcher->lock);
209
210     msg_Dbg( p_this, "Destroyed" );
211 }
212
213 /* Destroy remaining objects */
214 static void ObjectGarbageCollector( playlist_t *p_playlist, bool b_force )
215 {
216     if( !b_force )
217     {
218         if( mdate() - p_playlist->gc_date < 1000000 )
219         {
220             p_playlist->b_cant_sleep = true;
221             return;
222         }
223         else if( p_playlist->gc_date == 0 )
224             return;
225     }
226
227     p_playlist->b_cant_sleep = false;
228 }
229
230 /* Input Callback */
231 static void input_state_changed( const vlc_event_t * event, void * data )
232 {
233     (void)event;
234     playlist_t * p_playlist = data;
235     playlist_Signal( p_playlist );
236 }
237
238 /* Input Callback */
239 static void input_selected_stream_changed( const vlc_event_t * event, void * data )
240 {
241     (void)event;
242     playlist_t * p_playlist = data;
243     PL_LOCK;
244     p_playlist->gc_date = mdate();
245     vlc_object_signal_unlocked( p_playlist );
246     PL_UNLOCK;
247 }
248
249 /* Internals */
250 void playlist_release_current_input( playlist_t * p_playlist )
251 {
252     PL_ASSERT_LOCKED;
253
254     if( !pl_priv(p_playlist)->p_input ) return;
255
256     input_thread_t * p_input = pl_priv(p_playlist)->p_input;
257     vlc_event_manager_t * p_em = input_get_event_manager( p_input );
258
259     vlc_event_detach( p_em, vlc_InputStateChanged,
260                       input_state_changed, p_playlist );
261     vlc_event_detach( p_em, vlc_InputSelectedStreamChanged,
262                       input_selected_stream_changed, p_playlist );
263     pl_priv(p_playlist)->p_input = NULL;
264
265     /* Release the playlist lock, because we may get stuck
266      * in vlc_object_release() for some time. */
267     PL_UNLOCK;
268     vlc_thread_join( p_input );
269     vlc_object_release( p_input );
270     PL_LOCK;
271 }
272
273 void playlist_set_current_input(
274     playlist_t * p_playlist, input_thread_t * p_input )
275 {
276     PL_ASSERT_LOCKED;
277
278     playlist_release_current_input( p_playlist );
279
280     if( p_input )
281     {
282         vlc_object_hold( p_input );
283         pl_priv(p_playlist)->p_input = p_input;
284         vlc_event_manager_t * p_em = input_get_event_manager( p_input );
285         vlc_event_attach( p_em, vlc_InputStateChanged,
286                           input_state_changed, p_playlist );
287         vlc_event_attach( p_em, vlc_InputSelectedStreamChanged,
288                           input_selected_stream_changed, p_playlist );
289     }
290 }
291
292 /** Get current playing input.
293  */
294 input_thread_t * playlist_CurrentInput( playlist_t * p_playlist )
295 {
296     input_thread_t * p_input;
297     PL_LOCK;
298     p_input = pl_priv(p_playlist)->p_input;
299     if( p_input ) vlc_object_hold( p_input );
300     PL_UNLOCK;
301     return p_input;
302 }
303
304 /**
305  * @}
306  */
307
308 /** Accessor for status item and status nodes.
309  */
310 playlist_item_t * get_current_status_item( playlist_t * p_playlist )
311 {
312     PL_ASSERT_LOCKED;
313
314     return pl_priv(p_playlist)->status.p_item;
315 }
316
317 playlist_item_t * get_current_status_node( playlist_t * p_playlist )
318 {
319     PL_ASSERT_LOCKED;
320
321     return pl_priv(p_playlist)->status.p_node;
322 }
323
324 void set_current_status_item( playlist_t * p_playlist,
325     playlist_item_t * p_item )
326 {
327     PL_ASSERT_LOCKED;
328
329     if( pl_priv(p_playlist)->status.p_item &&
330         pl_priv(p_playlist)->status.p_item->i_flags & PLAYLIST_REMOVE_FLAG &&
331         pl_priv(p_playlist)->status.p_item != p_item )
332     {
333         /* It's unsafe given current design to delete a playlist item :(
334         playlist_ItemDelete( pl_priv(p_playlist)->status.p_item ); */
335     }
336     pl_priv(p_playlist)->status.p_item = p_item;
337 }
338
339 void set_current_status_node( playlist_t * p_playlist,
340     playlist_item_t * p_node )
341 {
342     PL_ASSERT_LOCKED;
343
344     if( pl_priv(p_playlist)->status.p_node &&
345         pl_priv(p_playlist)->status.p_node->i_flags & PLAYLIST_REMOVE_FLAG &&
346         pl_priv(p_playlist)->status.p_node != p_node )
347     {
348         /* It's unsafe given current design to delete a playlist item :(
349         playlist_ItemDelete( pl_priv(p_playlist)->status.p_node ); */
350     }
351     pl_priv(p_playlist)->status.p_node = p_node;
352 }
353
354 /**
355  * Main loop
356  *
357  * Main loop for the playlist. It should be entered with the
358  * playlist lock (otherwise input event may be lost)
359  * \param p_playlist the playlist object
360  * \return nothing
361  */
362 void playlist_MainLoop( playlist_t *p_playlist )
363 {
364     playlist_item_t *p_item = NULL;
365     bool b_playexit = var_GetBool( p_playlist, "play-and-exit" );
366
367     PL_ASSERT_LOCKED;
368
369     if( p_playlist->b_reset_currently_playing &&
370         mdate() - p_playlist->last_rebuild_date > 30000 ) // 30 ms
371     {
372         ResetCurrentlyPlaying( p_playlist, var_GetBool( p_playlist, "random" ),
373                                get_current_status_item( p_playlist ) );
374         p_playlist->last_rebuild_date = mdate();
375     }
376
377 check_input:
378     /* If there is an input, check that it doesn't need to die. */
379     if( pl_priv(p_playlist)->p_input )
380     {
381         if( pl_priv(p_playlist)->request.b_request && !pl_priv(p_playlist)->p_input->b_die )
382         {
383             PL_DEBUG( "incoming request - stopping current input" );
384             input_StopThread( pl_priv(p_playlist)->p_input );
385         }
386
387         /* This input is dead. Remove it ! */
388         if( pl_priv(p_playlist)->p_input->b_dead )
389         {
390             int i_activity;
391             input_thread_t *p_input;
392             sout_instance_t **pp_sout = &pl_priv(p_playlist)->p_sout;
393
394             PL_DEBUG( "dead input" );
395
396             p_input = pl_priv(p_playlist)->p_input;
397
398             assert( *pp_sout == NULL );
399             if( var_CreateGetBool( p_input, "sout-keep" ) )
400                 *pp_sout = input_DetachSout( p_input );
401
402             /* Destroy input */
403             playlist_release_current_input( p_playlist );
404
405             p_playlist->gc_date = mdate();
406             p_playlist->b_cant_sleep = true;
407
408             i_activity= var_GetInteger( p_playlist, "activity" );
409             var_SetInteger( p_playlist, "activity", i_activity -
410                             DEFAULT_INPUT_ACTIVITY );
411
412             goto check_input;
413         }
414         /* This input is dying, let it do */
415         else if( pl_priv(p_playlist)->p_input->b_die )
416         {
417             PL_DEBUG( "dying input" );
418             PL_UNLOCK;
419             msleep( INTF_IDLE_SLEEP );
420             PL_LOCK;
421             goto check_input;
422         }
423         /* This input has finished, ask it to die ! */
424         else if( pl_priv(p_playlist)->p_input->b_error
425                   || pl_priv(p_playlist)->p_input->b_eof )
426         {
427             PL_DEBUG( "finished input" );
428             input_StopThread( pl_priv(p_playlist)->p_input );
429             /* No need to wait here, we'll wait in the p_input->b_die case */
430             goto check_input;
431         }
432         else if( pl_priv(p_playlist)->p_input->i_state != INIT_S )
433         {
434             ObjectGarbageCollector( p_playlist, false );
435         }
436     }
437     else
438     {
439         /* No input. Several cases
440          *  - No request, running status -> start new item
441          *  - No request, stopped status -> collect garbage
442          *  - Request, running requested -> start new item
443          *  - Request, stopped requested -> collect garbage
444         */
445         int i_status = pl_priv(p_playlist)->request.b_request ?
446             pl_priv(p_playlist)->request.i_status : pl_priv(p_playlist)->status.i_status;
447         if( i_status != PLAYLIST_STOPPED )
448         {
449             msg_Dbg( p_playlist, "starting new item" );
450             p_item = playlist_NextItem( p_playlist );
451
452             if( p_item == NULL )
453             {
454                 msg_Dbg( p_playlist, "nothing to play" );
455                 pl_priv(p_playlist)->status.i_status = PLAYLIST_STOPPED;
456
457                 if( b_playexit == true )
458                 {
459                     msg_Info( p_playlist, "end of playlist, exiting" );
460                     vlc_object_kill( p_playlist->p_libvlc );
461                 }
462                 ObjectGarbageCollector( p_playlist, true );
463                 return;
464             }
465             playlist_PlayItem( p_playlist, p_item );
466             /* playlist_PlayItem loose input event, we need to recheck */
467             goto check_input;
468         }
469         else
470         {
471             const bool b_gc_forced = pl_priv(p_playlist)->status.i_status != PLAYLIST_STOPPED;
472
473             pl_priv(p_playlist)->status.i_status = PLAYLIST_STOPPED;
474
475             /* Collect garbage */
476             ObjectGarbageCollector( p_playlist, b_gc_forced );
477         }
478     }
479 }
480
481 /**
482  * Last loop
483  *
484  * The playlist is dying so do the last loop
485  * \param p_playlist the playlist object
486  * \return nothing
487 */
488 void playlist_LastLoop( playlist_t *p_playlist )
489 {
490     /* If there is an input, kill it */
491     while( 1 )
492     {
493         PL_LOCK;
494         if( pl_priv(p_playlist)->p_input == NULL )
495         {
496             PL_UNLOCK;
497             break;
498         }
499
500         if( pl_priv(p_playlist)->p_input->b_dead )
501         {
502             /* remove input */
503             playlist_release_current_input( p_playlist );
504
505             /* sout-keep: no need to anything here.
506              * The last input will destroy its sout, if any, by itself */
507
508             PL_UNLOCK;
509             continue;
510         }
511         else if( pl_priv(p_playlist)->p_input->b_die )
512         {
513             /* This input is dying, leave it alone */
514             ;
515         }
516         else if( pl_priv(p_playlist)->p_input->b_error || pl_priv(p_playlist)->p_input->b_eof )
517         {
518             input_StopThread( pl_priv(p_playlist)->p_input );
519             PL_UNLOCK;
520             continue;
521         }
522         else
523         {
524             pl_priv(p_playlist)->p_input->b_eof = 1;
525         }
526         PL_UNLOCK;
527
528         msleep( INTF_IDLE_SLEEP );
529     }
530
531 #ifdef ENABLE_SOUT
532     /* close the remaining sout-keep (if there was no input atm) */
533     sout_instance_t *p_sout = pl_priv(p_playlist)->p_sout;
534     if (p_sout)
535         sout_DeleteInstance( p_sout );
536 #endif
537
538     /* Core should have terminated all SDs before the playlist */
539     /* TODO: It fails to do so when not playing anything -- Courmisch */
540     playlist_ServicesDiscoveryKillAll( p_playlist );
541     playlist_MLDump( p_playlist );
542
543     PL_LOCK;
544
545     /* Release the current node */
546     set_current_status_node( p_playlist, NULL );
547
548     /* Release the current item */
549     set_current_status_item( p_playlist, NULL );
550
551     FOREACH_ARRAY( playlist_item_t *p_del, p_playlist->all_items )
552         free( p_del->pp_children );
553         vlc_gc_decref( p_del->p_input );
554         free( p_del );
555     FOREACH_END();
556     ARRAY_RESET( p_playlist->all_items );
557     FOREACH_ARRAY( playlist_item_t *p_del, p_playlist->items_to_delete )
558         free( p_del->pp_children );
559         vlc_gc_decref( p_del->p_input );
560         free( p_del );
561     FOREACH_END();
562     ARRAY_RESET( p_playlist->items_to_delete );
563
564     ARRAY_RESET( p_playlist->items );
565     ARRAY_RESET( p_playlist->current );
566
567     PL_UNLOCK;
568 }
569
570 /**
571  * Preparse queue loop
572  *
573  * @param p_obj preparse structure
574  * @return never
575  */
576 void *playlist_PreparseLoop( void *data )
577 {
578     playlist_preparse_t *p_preparse = data;
579     playlist_t *p_playlist = &((playlist_private_t *)(((char *)p_preparse)
580              - offsetof(playlist_private_t, preparse)))->public_data;
581
582     for( ;; )
583     {
584         input_item_t *p_current;
585
586         vlc_mutex_lock( &p_preparse->lock );
587         mutex_cleanup_push( &p_preparse->lock );
588
589         while( p_preparse->i_waiting == 0 )
590             vlc_cond_wait( &p_preparse->wait, &p_preparse->lock );
591
592         p_current = p_preparse->pp_waiting[0];
593         REMOVE_ELEM( p_preparse->pp_waiting, p_preparse->i_waiting, 0 );
594         vlc_cleanup_run( );
595
596         if( p_current )
597         {
598             int canc = vlc_savecancel ();
599             PL_LOCK;
600             if( p_current->i_type == ITEM_TYPE_FILE )
601             {
602                 stats_TimerStart( p_playlist, "Preparse run",
603                                   STATS_TIMER_PREPARSE );
604                 /* Do not preparse if it is already done (like by playing it) */
605                 if( !input_item_IsPreparsed( p_current ) )
606                 {
607                     PL_UNLOCK;
608                     input_Preparse( p_playlist, p_current );
609                     PL_LOCK;
610                 }
611                 stats_TimerStop( p_playlist, STATS_TIMER_PREPARSE );
612                 PL_UNLOCK;
613                 input_item_SetPreparsed( p_current, true );
614                 var_SetInteger( p_playlist, "item-change", p_current->i_id );
615                 PL_LOCK;
616             }
617             /* If we haven't retrieved enough meta, add to secondary queue
618              * which will run the "meta fetchers".
619              * This only checks for meta, not for art
620              * \todo don't do this for things we won't get meta for, like vids
621              */
622             char *psz_arturl = input_item_GetArtURL( p_current );
623             char *psz_name = input_item_GetName( p_current );
624             playlist_fetcher_t *p_fetcher = &pl_priv(p_playlist)->fetcher;
625             if( p_fetcher->i_art_policy == ALBUM_ART_ALL &&
626                 ( !psz_arturl || strncmp( psz_arturl, "file://", 7 ) ) )
627             {
628                 PL_DEBUG("meta ok for %s, need to fetch art", psz_name );
629                 vlc_mutex_lock( &p_fetcher->lock );
630                 INSERT_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting,
631                              p_fetcher->i_waiting, p_current);
632                 vlc_cond_signal( &p_fetcher->wait );
633                 vlc_mutex_unlock( &p_fetcher->lock );
634             }
635             else
636             {
637                 PL_DEBUG( "no fetch required for %s (art currently %s)",
638                           psz_name, psz_arturl );
639                 vlc_gc_decref( p_current );
640             }
641             free( psz_name );
642             free( psz_arturl );
643             PL_UNLOCK;
644             vlc_restorecancel( canc );
645         }
646
647         int i_activity = var_GetInteger( p_playlist, "activity" );
648         if( i_activity < 0 ) i_activity = 0;
649         /* Sleep at least 1ms */
650         msleep( (i_activity+1) * 1000 );
651     }
652
653     assert( 0 );
654     return NULL;
655 }
656
657 /**
658  * Fetcher loop
659  *
660  * \return never
661  */
662 void *playlist_FetcherLoop( void *data )
663 {
664     playlist_fetcher_t *p_fetcher = data;
665     playlist_t *p_playlist = &((playlist_private_t *)(((char *)p_fetcher)
666              - offsetof(playlist_private_t, fetcher)))->public_data;
667
668     for( ;; )
669     {
670         input_item_t *p_item;
671
672         vlc_mutex_lock( &p_fetcher->lock );
673         mutex_cleanup_push( &p_fetcher->lock );
674
675         while( p_fetcher->i_waiting == 0 )
676             vlc_cond_wait( &p_fetcher->wait, &p_fetcher->lock );
677
678         p_item = p_fetcher->pp_waiting[0];
679         REMOVE_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting, 0 );
680         vlc_cleanup_run( );
681
682         int canc = vlc_savecancel();
683         if( p_item )
684         {
685             int i_ret;
686
687             /* Check if it is not yet preparsed and if so wait for it
688              * (at most 0.5s)
689              * (This can happen if we fetch art on play)
690              * FIXME this doesn't work if we need to fetch meta before art...
691              */
692             for( i_ret = 0; i_ret < 10 && !input_item_IsPreparsed( p_item ); i_ret++ )
693             {
694                 bool b_break;
695                 PL_LOCK;
696                 b_break = ( !pl_priv(p_playlist)->p_input || input_GetItem(pl_priv(p_playlist)->p_input) != p_item  ||
697                             pl_priv(p_playlist)->p_input->b_die || pl_priv(p_playlist)->p_input->b_eof || pl_priv(p_playlist)->p_input->b_error );
698                 PL_UNLOCK;
699                 if( b_break )
700                     break;
701                 msleep( 50000 );
702             }
703
704             i_ret = input_ArtFind( p_playlist, p_item );
705             if( i_ret == 1 )
706             {
707                 PL_DEBUG( "downloading art for %s", p_item->psz_name );
708                 if( input_DownloadAndCacheArt( p_playlist, p_item ) )
709                     input_item_SetArtNotFound( p_item, true );
710                 else {
711                     input_item_SetArtFetched( p_item, true );
712                     var_SetInteger( p_playlist, "item-change",
713                                     p_item->i_id );
714                 }
715             }
716             else if( i_ret == 0 ) /* Was in cache */
717             {
718                 PL_DEBUG( "found art for %s in cache", p_item->psz_name );
719                 input_item_SetArtFetched( p_item, true );
720                 var_SetInteger( p_playlist, "item-change", p_item->i_id );
721             }
722             else
723             {
724                 PL_DEBUG( "art not found for %s", p_item->psz_name );
725                 input_item_SetArtNotFound( p_item, true );
726             }
727             vlc_gc_decref( p_item );
728         }
729         vlc_restorecancel( canc );
730
731         int i_activity = var_GetInteger( p_playlist, "activity" );
732         if( i_activity < 0 ) i_activity = 0;
733         /* Sleep at least 1ms */
734         msleep( (i_activity+1) * 1000 );
735     }
736
737     assert( 0 );
738     return NULL;
739 }
740
741 static void VariablesInit( playlist_t *p_playlist )
742 {
743     vlc_value_t val;
744     /* These variables control updates */
745     var_Create( p_playlist, "intf-change", VLC_VAR_BOOL );
746     val.b_bool = true;
747     var_Set( p_playlist, "intf-change", val );
748
749     var_Create( p_playlist, "item-change", VLC_VAR_INTEGER );
750     val.i_int = -1;
751     var_Set( p_playlist, "item-change", val );
752
753     var_Create( p_playlist, "item-deleted", VLC_VAR_INTEGER );
754     val.i_int = -1;
755     var_Set( p_playlist, "item-deleted", val );
756
757     var_Create( p_playlist, "item-append", VLC_VAR_ADDRESS );
758
759     var_Create( p_playlist, "playlist-current", VLC_VAR_INTEGER );
760     val.i_int = -1;
761     var_Set( p_playlist, "playlist-current", val );
762
763     var_Create( p_playlist, "activity", VLC_VAR_INTEGER );
764     var_SetInteger( p_playlist, "activity", 0 );
765
766     /* Variables to control playback */
767     var_CreateGetBool( p_playlist, "play-and-stop" );
768     var_CreateGetBool( p_playlist, "play-and-exit" );
769     var_CreateGetBool( p_playlist, "random" );
770     var_CreateGetBool( p_playlist, "repeat" );
771     var_CreateGetBool( p_playlist, "loop" );
772
773     var_AddCallback( p_playlist, "random", RandomCallback, NULL );
774 }
775
776 int playlist_CurrentId( playlist_t * p_playlist )
777 {
778     return pl_priv(p_playlist)->status.p_item->i_id;
779 }
780
781 bool playlist_IsPlaying( playlist_t * p_playlist )
782 {
783     return ( pl_priv(p_playlist)->status.i_status == PLAYLIST_RUNNING &&
784             !(pl_priv(p_playlist)->request.b_request && pl_priv(p_playlist)->request.i_status == PLAYLIST_STOPPED) );
785 }
786
787 playlist_item_t * playlist_CurrentPlayingItem( playlist_t * p_playlist )
788 {
789     return pl_priv(p_playlist)->status.p_item;
790 }
791
792 int playlist_Status( playlist_t * p_playlist )
793 {
794     return pl_priv(p_playlist)->status.i_status;
795 }