1 /*****************************************************************************
2 * engine.c : Run the playlist and handle its control
3 *****************************************************************************
4 * Copyright (C) 1999-2008 the VideoLAN team
6 * Authors: Samuel Hocevar <sam@zoy.org>
7 * Clément Stenac <zorglub@videolan.org>
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.
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.
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 *****************************************************************************/
29 #include <vlc_common.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 */
36 /*****************************************************************************
38 *****************************************************************************/
39 static void VariablesInit( playlist_t
*p_playlist
);
40 static void playlist_Destructor( vlc_object_t
* p_this
);
42 static int RandomCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
43 vlc_value_t oldval
, vlc_value_t newval
, void *a
)
45 (void)psz_cmd
; (void)oldval
; (void)newval
; (void)a
;
47 ((playlist_t
*)p_this
)->b_reset_currently_playing
= true;
48 playlist_Signal( ((playlist_t
*)p_this
) );
55 * Create a playlist structure.
56 * \param p_parent the vlc object that is to be the parent of this playlist
57 * \return a pointer to the created playlist, or NULL on error
59 playlist_t
* playlist_Create( vlc_object_t
*p_parent
)
61 static const char playlist_name
[] = "playlist";
62 playlist_t
*p_playlist
;
65 /* Allocate structure */
66 p_playlist
= vlc_custom_create( p_parent
, sizeof( *p_playlist
),
67 VLC_OBJECT_GENERIC
, playlist_name
);
71 TAB_INIT( p_playlist
->i_sds
, p_playlist
->pp_sds
);
72 MALLOC_NULL( p_playlist
->p
, playlist_private_t
);
73 memset( p_playlist
->p
, 0, sizeof( playlist_private_t
) );
75 libvlc_priv(p_parent
->p_libvlc
)->p_playlist
= p_playlist
;
77 VariablesInit( p_playlist
);
79 /* Initialise data structures */
80 p_playlist
->i_last_playlist_id
= 0;
81 p_playlist
->p_input
= NULL
;
83 p_playlist
->gc_date
= 0;
84 p_playlist
->b_cant_sleep
= false;
86 ARRAY_INIT( p_playlist
->items
);
87 ARRAY_INIT( p_playlist
->all_items
);
88 ARRAY_INIT( p_playlist
->items_to_delete
);
89 ARRAY_INIT( p_playlist
->current
);
91 p_playlist
->i_current_index
= 0;
92 p_playlist
->b_reset_currently_playing
= true;
93 p_playlist
->last_rebuild_date
= 0;
95 p_playlist
->b_tree
= var_CreateGetBool( p_playlist
, "playlist-tree" );
97 p_playlist
->b_doing_ml
= false;
99 p_playlist
->b_auto_preparse
=
100 var_CreateGetBool( p_playlist
, "auto-preparse" ) ;
102 PL_LOCK
; /* playlist_NodeCreate will check for it */
103 p_playlist
->p_root_category
= playlist_NodeCreate( p_playlist
, NULL
, NULL
,
105 p_playlist
->p_root_onelevel
= playlist_NodeCreate( p_playlist
, NULL
, NULL
,
106 0, p_playlist
->p_root_category
->p_input
);
109 if( !p_playlist
->p_root_category
|| !p_playlist
->p_root_onelevel
)
112 /* Create playlist and media library */
113 PL_LOCK
; /* playlist_NodesPairCreate will check for it */
114 playlist_NodesPairCreate( p_playlist
, _( "Playlist" ),
115 &p_playlist
->p_local_category
,
116 &p_playlist
->p_local_onelevel
, false );
119 p_playlist
->p_local_category
->i_flags
|= PLAYLIST_RO_FLAG
;
120 p_playlist
->p_local_onelevel
->i_flags
|= PLAYLIST_RO_FLAG
;
122 if( !p_playlist
->p_local_category
|| !p_playlist
->p_local_onelevel
||
123 !p_playlist
->p_local_category
->p_input
||
124 !p_playlist
->p_local_onelevel
->p_input
)
127 if( config_GetInt( p_playlist
, "media-library") )
129 PL_LOCK
; /* playlist_NodesPairCreate will check for it */
130 playlist_NodesPairCreate( p_playlist
, _( "Media Library" ),
131 &p_playlist
->p_ml_category
,
132 &p_playlist
->p_ml_onelevel
, false );
135 if(!p_playlist
->p_ml_category
|| !p_playlist
->p_ml_onelevel
)
138 p_playlist
->p_ml_category
->i_flags
|= PLAYLIST_RO_FLAG
;
139 p_playlist
->p_ml_onelevel
->i_flags
|= PLAYLIST_RO_FLAG
;
143 p_playlist
->p_ml_category
= p_playlist
->p_ml_onelevel
= NULL
;
147 p_playlist
->status
.p_item
= NULL
;
148 p_playlist
->status
.p_node
= p_playlist
->p_local_onelevel
;
149 p_playlist
->request
.b_request
= false;
150 p_playlist
->status
.i_status
= PLAYLIST_STOPPED
;
152 p_playlist
->i_sort
= SORT_ID
;
153 p_playlist
->i_order
= ORDER_NORMAL
;
156 b_save
= p_playlist
->b_auto_preparse
;
157 p_playlist
->b_auto_preparse
= false;
158 playlist_MLLoad( p_playlist
);
159 p_playlist
->b_auto_preparse
= true;
161 vlc_object_set_destructor( p_playlist
, playlist_Destructor
);
169 * Destroy a playlist structure.
170 * \param p_playlist the playlist object
174 static void playlist_Destructor( vlc_object_t
* p_this
)
176 playlist_t
* p_playlist
= (playlist_t
*)p_this
;
178 if( p_playlist
->p
->p_preparse
)
180 vlc_object_release( p_playlist
->p
->p_preparse
);
183 if( p_playlist
->p
->p_fetcher
)
185 vlc_object_release( p_playlist
->p
->p_fetcher
);
187 msg_Dbg( p_this
, "Destroyed" );
190 /* Destroy remaining objects */
191 static void ObjectGarbageCollector( playlist_t
*p_playlist
, bool b_force
)
195 if( mdate() - p_playlist
->gc_date
< 1000000 )
197 p_playlist
->b_cant_sleep
= true;
200 else if( p_playlist
->gc_date
== 0 )
204 p_playlist
->b_cant_sleep
= false;
208 static void input_state_changed( const vlc_event_t
* event
, void * data
)
211 playlist_t
* p_playlist
= data
;
212 playlist_Signal( p_playlist
);
216 static void input_selected_stream_changed( const vlc_event_t
* event
, void * data
)
219 playlist_t
* p_playlist
= data
;
221 p_playlist
->gc_date
= mdate();
222 vlc_object_signal_unlocked( p_playlist
);
227 void playlist_release_current_input( playlist_t
* p_playlist
)
231 if( !p_playlist
->p_input
) return;
233 input_thread_t
* p_input
= p_playlist
->p_input
;
234 vlc_event_manager_t
* p_em
= input_get_event_manager( p_input
);
236 vlc_event_detach( p_em
, vlc_InputStateChanged
,
237 input_state_changed
, p_playlist
);
238 vlc_event_detach( p_em
, vlc_InputSelectedStreamChanged
,
239 input_selected_stream_changed
, p_playlist
);
240 p_playlist
->p_input
= NULL
;
242 /* Release the playlist lock, because we may get stuck
243 * in vlc_object_release() for some time. */
245 vlc_thread_join( p_input
);
246 vlc_object_release( p_input
);
250 void playlist_set_current_input(
251 playlist_t
* p_playlist
, input_thread_t
* p_input
)
255 playlist_release_current_input( p_playlist
);
259 vlc_object_yield( p_input
);
260 p_playlist
->p_input
= p_input
;
261 vlc_event_manager_t
* p_em
= input_get_event_manager( p_input
);
262 vlc_event_attach( p_em
, vlc_InputStateChanged
,
263 input_state_changed
, p_playlist
);
264 vlc_event_attach( p_em
, vlc_InputSelectedStreamChanged
,
265 input_selected_stream_changed
, p_playlist
);
269 /** Get current playing input.
271 input_thread_t
* playlist_CurrentInput( playlist_t
* p_playlist
)
273 input_thread_t
* p_input
;
275 p_input
= p_playlist
->p_input
;
276 if( p_input
) vlc_object_yield( p_input
);
285 /** Accessor for status item and status nodes.
287 playlist_item_t
* get_current_status_item( playlist_t
* p_playlist
)
291 return p_playlist
->status
.p_item
;
294 playlist_item_t
* get_current_status_node( playlist_t
* p_playlist
)
298 return p_playlist
->status
.p_node
;
301 void set_current_status_item( playlist_t
* p_playlist
,
302 playlist_item_t
* p_item
)
306 if( p_playlist
->status
.p_item
&&
307 p_playlist
->status
.p_item
->i_flags
& PLAYLIST_REMOVE_FLAG
&&
308 p_playlist
->status
.p_item
!= p_item
)
310 /* It's unsafe given current design to delete a playlist item :(
311 playlist_ItemDelete( p_playlist->status.p_item ); */
313 p_playlist
->status
.p_item
= p_item
;
316 void set_current_status_node( playlist_t
* p_playlist
,
317 playlist_item_t
* p_node
)
321 if( p_playlist
->status
.p_node
&&
322 p_playlist
->status
.p_node
->i_flags
& PLAYLIST_REMOVE_FLAG
&&
323 p_playlist
->status
.p_node
!= p_node
)
325 /* It's unsafe given current design to delete a playlist item :(
326 playlist_ItemDelete( p_playlist->status.p_node ); */
328 p_playlist
->status
.p_node
= p_node
;
334 * Main loop for the playlist. It should be entered with the
335 * playlist lock (otherwise input event may be lost)
336 * \param p_playlist the playlist object
339 void playlist_MainLoop( playlist_t
*p_playlist
)
341 playlist_item_t
*p_item
= NULL
;
342 bool b_playexit
= var_GetBool( p_playlist
, "play-and-exit" );
346 if( p_playlist
->b_reset_currently_playing
&&
347 mdate() - p_playlist
->last_rebuild_date
> 30000 ) // 30 ms
349 ResetCurrentlyPlaying( p_playlist
, var_GetBool( p_playlist
, "random" ),
350 get_current_status_item( p_playlist
) );
351 p_playlist
->last_rebuild_date
= mdate();
355 /* If there is an input, check that it doesn't need to die. */
356 if( p_playlist
->p_input
)
358 if( p_playlist
->request
.b_request
&& !p_playlist
->p_input
->b_die
)
360 PL_DEBUG( "incoming request - stopping current input" );
361 input_StopThread( p_playlist
->p_input
);
364 /* This input is dead. Remove it ! */
365 if( p_playlist
->p_input
->b_dead
)
368 input_thread_t
*p_input
;
369 sout_instance_t
**pp_sout
= &p_playlist
->p
->p_sout
;
371 PL_DEBUG( "dead input" );
373 p_input
= p_playlist
->p_input
;
375 assert( *pp_sout
== NULL
);
376 if( var_CreateGetBool( p_input
, "sout-keep" ) )
377 *pp_sout
= input_DetachSout( p_input
);
380 playlist_release_current_input( p_playlist
);
382 p_playlist
->gc_date
= mdate();
383 p_playlist
->b_cant_sleep
= true;
385 i_activity
= var_GetInteger( p_playlist
, "activity" );
386 var_SetInteger( p_playlist
, "activity", i_activity
-
387 DEFAULT_INPUT_ACTIVITY
);
391 /* This input is dying, let it do */
392 else if( p_playlist
->p_input
->b_die
)
394 PL_DEBUG( "dying input" );
396 msleep( INTF_IDLE_SLEEP
);
400 /* This input has finished, ask it to die ! */
401 else if( p_playlist
->p_input
->b_error
402 || p_playlist
->p_input
->b_eof
)
404 PL_DEBUG( "finished input" );
405 input_StopThread( p_playlist
->p_input
);
406 /* No need to wait here, we'll wait in the p_input->b_die case */
409 else if( p_playlist
->p_input
->i_state
!= INIT_S
)
411 ObjectGarbageCollector( p_playlist
, false );
416 /* No input. Several cases
417 * - No request, running status -> start new item
418 * - No request, stopped status -> collect garbage
419 * - Request, running requested -> start new item
420 * - Request, stopped requested -> collect garbage
422 int i_status
= p_playlist
->request
.b_request
?
423 p_playlist
->request
.i_status
: p_playlist
->status
.i_status
;
424 if( i_status
!= PLAYLIST_STOPPED
)
426 msg_Dbg( p_playlist
, "starting new item" );
427 p_item
= playlist_NextItem( p_playlist
);
431 msg_Dbg( p_playlist
, "nothing to play" );
432 p_playlist
->status
.i_status
= PLAYLIST_STOPPED
;
434 if( b_playexit
== true )
436 msg_Info( p_playlist
, "end of playlist, exiting" );
437 vlc_object_kill( p_playlist
->p_libvlc
);
439 ObjectGarbageCollector( p_playlist
, true );
442 playlist_PlayItem( p_playlist
, p_item
);
443 /* playlist_PlayItem loose input event, we need to recheck */
448 const bool b_gc_forced
= p_playlist
->status
.i_status
!= PLAYLIST_STOPPED
;
450 p_playlist
->status
.i_status
= PLAYLIST_STOPPED
;
452 /* Collect garbage */
453 ObjectGarbageCollector( p_playlist
, b_gc_forced
);
461 * The playlist is dying so do the last loop
462 * \param p_playlist the playlist object
465 void playlist_LastLoop( playlist_t
*p_playlist
)
467 /* If there is an input, kill it */
471 if( p_playlist
->p_input
== NULL
)
477 if( p_playlist
->p_input
->b_dead
)
480 playlist_release_current_input( p_playlist
);
482 /* sout-keep: no need to anything here.
483 * The last input will destroy its sout, if any, by itself */
488 else if( p_playlist
->p_input
->b_die
)
490 /* This input is dying, leave it alone */
493 else if( p_playlist
->p_input
->b_error
|| p_playlist
->p_input
->b_eof
)
495 input_StopThread( p_playlist
->p_input
);
501 p_playlist
->p_input
->b_eof
= 1;
505 msleep( INTF_IDLE_SLEEP
);
509 /* close the remaining sout-keep (if there was no input atm) */
510 sout_instance_t
*p_sout
= p_playlist
->p
->p_sout
;
512 sout_DeleteInstance( p_sout
);
515 /* Core should have terminated all SDs before the playlist */
516 /* TODO: It fails to do so when not playing anything -- Courmisch */
517 playlist_ServicesDiscoveryKillAll( p_playlist
);
518 playlist_MLDump( p_playlist
);
520 vlc_object_kill( p_playlist
->p
->p_preparse
);
521 vlc_thread_join( p_playlist
->p
->p_preparse
);
522 vlc_object_kill( p_playlist
->p
->p_fetcher
);
523 vlc_thread_join( p_playlist
->p
->p_fetcher
);
527 /* Release the current node */
528 set_current_status_node( p_playlist
, NULL
);
530 /* Release the current item */
531 set_current_status_item( p_playlist
, NULL
);
533 FOREACH_ARRAY( playlist_item_t
*p_del
, p_playlist
->all_items
)
534 free( p_del
->pp_children
);
535 vlc_gc_decref( p_del
->p_input
);
538 ARRAY_RESET( p_playlist
->all_items
);
539 FOREACH_ARRAY( playlist_item_t
*p_del
, p_playlist
->items_to_delete
)
540 free( p_del
->pp_children
);
541 vlc_gc_decref( p_del
->p_input
);
544 ARRAY_RESET( p_playlist
->items_to_delete
);
546 ARRAY_RESET( p_playlist
->items
);
547 ARRAY_RESET( p_playlist
->current
);
555 * Main loop for preparser queue
556 * \param p_obj items to preparse
559 void playlist_PreparseLoop( playlist_preparse_t
*p_obj
)
561 playlist_t
*p_playlist
= (playlist_t
*)p_obj
->p_parent
;
562 input_item_t
*p_current
;
565 vlc_object_lock( p_obj
);
567 while( vlc_object_alive( p_obj
) )
569 if( p_obj
->i_waiting
== 0 )
571 vlc_object_wait( p_obj
);
575 p_current
= p_obj
->pp_waiting
[0];
576 REMOVE_ELEM( p_obj
->pp_waiting
, p_obj
->i_waiting
, 0 );
577 vlc_object_unlock( p_obj
);
582 if( p_current
->i_type
== ITEM_TYPE_FILE
)
584 stats_TimerStart( p_playlist
, "Preparse run",
585 STATS_TIMER_PREPARSE
);
586 /* Do not preparse if it is already done (like by playing it) */
587 if( !input_item_IsPreparsed( p_current
) )
590 input_Preparse( p_playlist
, p_current
);
593 stats_TimerStop( p_playlist
, STATS_TIMER_PREPARSE
);
595 input_item_SetPreparsed( p_current
, true );
596 var_SetInteger( p_playlist
, "item-change", p_current
->i_id
);
599 /* If we haven't retrieved enough meta, add to secondary queue
600 * which will run the "meta fetchers".
601 * This only checks for meta, not for art
602 * \todo don't do this for things we won't get meta for, like vids
604 char *psz_arturl
= input_item_GetArtURL( p_current
);
605 char *psz_name
= input_item_GetName( p_current
);
606 if( p_playlist
->p
->p_fetcher
->i_art_policy
== ALBUM_ART_ALL
&&
607 ( !psz_arturl
|| strncmp( psz_arturl
, "file://", 7 ) ) )
609 PL_DEBUG("meta ok for %s, need to fetch art", psz_name
);
610 vlc_object_lock( p_playlist
->p
->p_fetcher
);
611 if( vlc_object_alive( p_playlist
->p
->p_fetcher
) )
613 INSERT_ELEM( p_playlist
->p
->p_fetcher
->pp_waiting
,
614 p_playlist
->p
->p_fetcher
->i_waiting
,
615 p_playlist
->p
->p_fetcher
->i_waiting
, p_current
);
616 vlc_object_signal_unlocked( p_playlist
->p
->p_fetcher
);
619 vlc_gc_decref( p_current
);
620 vlc_object_unlock( p_playlist
->p
->p_fetcher
);
624 PL_DEBUG( "no fetch required for %s (art currently %s)",
625 psz_name
, psz_arturl
);
626 vlc_gc_decref( p_current
);
635 vlc_object_lock( p_obj
);
636 i_activity
= var_GetInteger( p_playlist
, "activity" );
637 if( i_activity
< 0 ) i_activity
= 0;
638 vlc_object_unlock( p_obj
);
639 /* Sleep at least 1ms */
640 msleep( (i_activity
+1) * 1000 );
641 vlc_object_lock( p_obj
);
644 while( p_obj
->i_waiting
> 0 )
646 vlc_gc_decref( p_obj
->pp_waiting
[0] );
647 REMOVE_ELEM( p_obj
->pp_waiting
, p_obj
->i_waiting
, 0 );
650 vlc_object_unlock( p_obj
);
656 * Main loop for secondary preparser queue
657 * \param p_obj items to preparse
660 void playlist_FetcherLoop( playlist_fetcher_t
*p_obj
)
662 playlist_t
*p_playlist
= (playlist_t
*)p_obj
->p_parent
;
663 input_item_t
*p_item
;
666 vlc_object_lock( p_obj
);
668 while( vlc_object_alive( p_obj
) )
670 if( p_obj
->i_waiting
== 0 )
672 vlc_object_wait( p_obj
);
676 p_item
= p_obj
->pp_waiting
[0];
677 REMOVE_ELEM( p_obj
->pp_waiting
, p_obj
->i_waiting
, 0 );
678 vlc_object_unlock( p_obj
);
683 /* Check if it is not yet preparsed and if so wait for it (at most 0.5s)
684 * (This can happen if we fetch art on play)
685 * FIXME this doesn't work if we need to fetch meta before art ... */
686 for( i_ret
= 0; i_ret
< 10 && !input_item_IsPreparsed( p_item
); i_ret
++ )
690 b_break
= ( !p_playlist
->p_input
|| input_GetItem(p_playlist
->p_input
) != p_item
||
691 p_playlist
->p_input
->b_die
|| p_playlist
->p_input
->b_eof
|| p_playlist
->p_input
->b_error
);
698 i_ret
= input_ArtFind( p_playlist
, p_item
);
701 PL_DEBUG( "downloading art for %s", p_item
->psz_name
);
702 if( input_DownloadAndCacheArt( p_playlist
, p_item
) )
703 input_item_SetArtNotFound( p_item
, true );
705 input_item_SetArtFetched( p_item
, true );
706 var_SetInteger( p_playlist
, "item-change",
710 else if( i_ret
== 0 ) /* Was in cache */
712 PL_DEBUG( "found art for %s in cache", p_item
->psz_name
);
713 input_item_SetArtFetched( p_item
, true );
714 var_SetInteger( p_playlist
, "item-change", p_item
->i_id
);
718 PL_DEBUG( "art not found for %s", p_item
->psz_name
);
719 input_item_SetArtNotFound( p_item
, true );
721 vlc_gc_decref( p_item
);
723 vlc_object_lock( p_obj
);
724 i_activity
= var_GetInteger( p_playlist
, "activity" );
725 if( i_activity
< 0 ) i_activity
= 0;
726 vlc_object_unlock( p_obj
);
727 /* Sleep at least 1ms */
728 msleep( (i_activity
+1) * 1000 );
729 vlc_object_lock( p_obj
);
732 while( p_obj
->i_waiting
> 0 )
734 vlc_gc_decref( p_obj
->pp_waiting
[0] );
735 REMOVE_ELEM( p_obj
->pp_waiting
, p_obj
->i_waiting
, 0 );
738 vlc_object_unlock( p_obj
);
741 static void VariablesInit( playlist_t
*p_playlist
)
744 /* These variables control updates */
745 var_Create( p_playlist
, "intf-change", VLC_VAR_BOOL
);
747 var_Set( p_playlist
, "intf-change", val
);
749 var_Create( p_playlist
, "item-change", VLC_VAR_INTEGER
);
751 var_Set( p_playlist
, "item-change", val
);
753 var_Create( p_playlist
, "item-deleted", VLC_VAR_INTEGER
);
755 var_Set( p_playlist
, "item-deleted", val
);
757 var_Create( p_playlist
, "item-append", VLC_VAR_ADDRESS
);
759 var_Create( p_playlist
, "playlist-current", VLC_VAR_INTEGER
);
761 var_Set( p_playlist
, "playlist-current", val
);
763 var_Create( p_playlist
, "activity", VLC_VAR_INTEGER
);
764 var_SetInteger( p_playlist
, "activity", 0 );
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" );
773 var_AddCallback( p_playlist
, "random", RandomCallback
, NULL
);