1 /*****************************************************************************
2 * playlist.c : Playlist management functions
3 *****************************************************************************
4 * Copyright (C) 1999-2001 VideoLAN
5 * $Id: playlist.c,v 1.18 2002/11/12 21:20:36 gbazin Exp $
7 * Authors: Samuel Hocevar <sam@zoy.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., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
22 *****************************************************************************/
23 #include <stdlib.h> /* free(), strtol() */
24 #include <stdio.h> /* sprintf() */
25 #include <string.h> /* strerror() */
29 #include "stream_control.h"
30 #include "input_ext-intf.h"
32 #include "vlc_playlist.h"
34 #define PLAYLIST_STOPPED 0
35 #define PLAYLIST_RUNNING 1
37 /*****************************************************************************
39 *****************************************************************************/
40 static void RunThread ( playlist_t * );
41 static void SkipItem ( playlist_t *, int );
42 static void PlayItem ( playlist_t * );
44 static void Poubellize ( playlist_t *, input_thread_t * );
46 /*****************************************************************************
47 * playlist_Create: create playlist
48 *****************************************************************************
49 * Create a playlist structure.
50 *****************************************************************************/
51 playlist_t * __playlist_Create ( vlc_object_t *p_parent )
53 playlist_t *p_playlist;
55 /* Allocate structure */
56 p_playlist = vlc_object_create( p_parent, VLC_OBJECT_PLAYLIST );
59 msg_Err( p_parent, "out of memory" );
63 p_playlist->p_input = NULL;
64 p_playlist->i_status = PLAYLIST_STOPPED;
65 p_playlist->i_index = -1;
66 p_playlist->i_size = 0;
67 p_playlist->pp_items = NULL;
69 if( vlc_thread_create( p_playlist, "playlist", RunThread,
70 VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
72 msg_Err( p_playlist, "cannot spawn playlist thread" );
73 vlc_object_destroy( p_playlist );
77 /* The object has been initialized, now attach it */
78 vlc_object_attach( p_playlist, p_parent );
83 /*****************************************************************************
84 * playlist_Destroy: destroy the playlist
85 *****************************************************************************
86 * Delete all items in the playlist and free the playlist structure.
87 *****************************************************************************/
88 void playlist_Destroy( playlist_t * p_playlist )
90 p_playlist->b_die = 1;
92 vlc_thread_join( p_playlist );
94 vlc_object_destroy( p_playlist );
97 /*****************************************************************************
98 * playlist_Add: add an item to the playlist
99 *****************************************************************************
100 * Add an item to the playlist at position i_pos. If i_pos is PLAYLIST_END,
101 * add it at the end regardless of the playlist current size.
102 *****************************************************************************/
103 int playlist_Add( playlist_t *p_playlist, const char * psz_target,
104 int i_mode, int i_pos )
106 playlist_item_t *p_item;
108 msg_Dbg( p_playlist, "adding playlist item « %s »", psz_target );
110 /* Create the new playlist item */
111 p_item = malloc( sizeof( playlist_item_t ) );
114 msg_Err( p_playlist, "out of memory" );
117 p_item->psz_name = strdup( psz_target );
119 p_item->i_status = 0;
120 p_item->b_autodeletion = VLC_FALSE;
122 vlc_mutex_lock( &p_playlist->object_lock );
124 /* Do a few boundary checks and allocate space for the item */
125 if( i_pos == PLAYLIST_END )
127 if( i_mode & PLAYLIST_INSERT )
129 i_mode &= ~PLAYLIST_INSERT;
130 i_mode |= PLAYLIST_APPEND;
133 i_pos = p_playlist->i_size - 1;
136 if( !(i_mode & PLAYLIST_REPLACE)
137 || i_pos < 0 || i_pos >= p_playlist->i_size )
139 /* Additional boundary checks */
140 if( i_mode & PLAYLIST_APPEND )
149 else if( i_pos > p_playlist->i_size )
151 i_pos = p_playlist->i_size;
154 INSERT_ELEM( p_playlist->pp_items,
159 if( p_playlist->i_index >= i_pos )
161 p_playlist->i_index++;
166 /* i_mode == PLAYLIST_REPLACE and 0 <= i_pos < p_playlist->i_size */
167 free( p_playlist->pp_items[i_pos]->psz_name );
168 /* XXX: what if the item is still in use? */
169 free( p_playlist->pp_items[i_pos] );
170 p_playlist->pp_items[i_pos] = p_item;
173 if( i_mode & PLAYLIST_GO )
175 p_playlist->i_index = i_pos;
176 if( p_playlist->p_input )
178 input_StopThread( p_playlist->p_input );
180 p_playlist->i_status = PLAYLIST_RUNNING;
183 vlc_mutex_unlock( &p_playlist->object_lock );
188 /*****************************************************************************
189 * playlist_Delete: delete an item from the playlist
190 *****************************************************************************
191 * Delete the item in the playlist with position i_pos.
192 *****************************************************************************/
193 int playlist_Delete( playlist_t * p_playlist, int i_pos )
195 vlc_mutex_lock( &p_playlist->object_lock );
197 if( i_pos >= 0 && i_pos < p_playlist->i_size )
199 msg_Dbg( p_playlist, "deleting playlist item « %s »",
200 p_playlist->pp_items[i_pos]->psz_name );
202 free( p_playlist->pp_items[i_pos]->psz_name );
203 /* XXX: what if the item is still in use? */
204 free( p_playlist->pp_items[i_pos] );
206 if( i_pos < p_playlist->i_index )
208 p_playlist->i_index--;
211 /* Renumber the playlist */
212 REMOVE_ELEM( p_playlist->pp_items,
217 vlc_mutex_unlock( &p_playlist->object_lock );
222 /*****************************************************************************
223 * playlist_Command: do a playlist action
224 *****************************************************************************
226 *****************************************************************************/
227 void playlist_Command( playlist_t * p_playlist, int i_command, int i_arg )
229 vlc_mutex_lock( &p_playlist->object_lock );
234 p_playlist->i_status = PLAYLIST_STOPPED;
235 if( p_playlist->p_input )
237 input_StopThread( p_playlist->p_input );
242 p_playlist->i_status = PLAYLIST_RUNNING;
246 p_playlist->i_status = PLAYLIST_STOPPED;
247 SkipItem( p_playlist, i_arg );
248 if( p_playlist->p_input )
250 input_StopThread( p_playlist->p_input );
252 p_playlist->i_status = PLAYLIST_RUNNING;
256 if( i_arg >= 0 && i_arg < p_playlist->i_size )
258 p_playlist->i_index = i_arg;
259 if( p_playlist->p_input )
261 input_StopThread( p_playlist->p_input );
263 p_playlist->i_status = PLAYLIST_RUNNING;
268 msg_Err( p_playlist, "unknown playlist command" );
272 vlc_mutex_unlock( &p_playlist->object_lock );
277 /* Following functions are local */
279 /*****************************************************************************
280 * RunThread: main playlist thread
281 *****************************************************************************/
282 static void RunThread ( playlist_t *p_playlist )
284 /* Tell above that we're ready */
285 vlc_thread_ready( p_playlist );
287 while( !p_playlist->b_die )
289 vlc_mutex_lock( &p_playlist->object_lock );
291 /* If there is an input, check that it doesn't need to die. */
292 if( p_playlist->p_input )
294 /* This input is dead. Remove it ! */
295 if( p_playlist->p_input->b_dead )
297 input_thread_t *p_input;
299 /* Unlink current input */
300 p_input = p_playlist->p_input;
301 p_playlist->p_input = NULL;
302 vlc_object_detach( p_input );
304 /* Release the playlist lock, because we may get stuck
305 * in input_DestroyThread() for some time. */
306 vlc_mutex_unlock( &p_playlist->object_lock );
308 /* Check for autodeletion */
309 if( p_playlist->pp_items[p_playlist->i_index]->b_autodeletion )
310 playlist_Delete( p_playlist, p_playlist->i_index );
313 input_DestroyThread( p_input );
314 vlc_object_destroy( p_input );
317 /* This input is dying, let him do */
318 else if( p_playlist->p_input->b_die )
322 /* This input has finished, ask him to die ! */
323 else if( p_playlist->p_input->b_error
324 || p_playlist->p_input->b_eof )
326 /* Select the next playlist item */
327 SkipItem( p_playlist, 1 );
329 /* Release the playlist lock, because we may get stuck
330 * in input_StopThread() for some time. */
331 vlc_mutex_unlock( &p_playlist->object_lock );
332 input_StopThread( p_playlist->p_input );
336 else if( p_playlist->i_status != PLAYLIST_STOPPED )
338 PlayItem( p_playlist );
341 vlc_mutex_unlock( &p_playlist->object_lock );
343 msleep( INTF_IDLE_SLEEP );
346 /* If there is an input, kill it */
349 vlc_mutex_lock( &p_playlist->object_lock );
351 if( p_playlist->p_input == NULL )
353 vlc_mutex_unlock( &p_playlist->object_lock );
357 if( p_playlist->p_input->b_dead )
359 input_thread_t *p_input;
361 /* Unlink current input */
362 p_input = p_playlist->p_input;
363 p_playlist->p_input = NULL;
364 vlc_object_detach( p_input );
365 vlc_mutex_unlock( &p_playlist->object_lock );
368 input_DestroyThread( p_input );
369 vlc_object_destroy( p_input );
372 else if( p_playlist->p_input->b_die )
374 /* This input is dying, leave him alone */
377 else if( p_playlist->p_input->b_error || p_playlist->p_input->b_eof )
379 vlc_mutex_unlock( &p_playlist->object_lock );
380 input_StopThread( p_playlist->p_input );
385 p_playlist->p_input->b_eof = 1;
388 vlc_mutex_unlock( &p_playlist->object_lock );
390 msleep( INTF_IDLE_SLEEP );
394 /*****************************************************************************
395 * SkipItem: go to Xth playlist item
396 *****************************************************************************
397 * This function calculates the position of the next playlist item, depending
398 * on the playlist course mode (forward, backward, random...).
399 *****************************************************************************/
400 static void SkipItem( playlist_t *p_playlist, int i_arg )
402 int i_oldindex = p_playlist->i_index;
405 /* If the playlist is empty, there is no current item */
406 if( p_playlist->i_size == 0 )
408 p_playlist->i_index = -1;
412 b_random = config_GetInt( p_playlist, "random" );
419 /* Simple random stuff - we cheat a bit to minimize the chances to
420 * get the same index again. */
421 i_arg = (int)((float)p_playlist->i_size * rand() / (RAND_MAX+1.0));
424 i_arg = (int)((float)p_playlist->i_size * rand() / (RAND_MAX+1.0));
428 p_playlist->i_index += i_arg;
431 if( p_playlist->i_index >= p_playlist->i_size )
433 if( p_playlist->i_status == PLAYLIST_STOPPED
435 || config_GetInt( p_playlist, "loop" ) )
437 p_playlist->i_index -= p_playlist->i_size
438 * ( p_playlist->i_index / p_playlist->i_size );
442 /* Don't loop by default: stop at playlist end */
443 p_playlist->i_index = i_oldindex;
444 p_playlist->i_status = PLAYLIST_STOPPED;
447 else if( p_playlist->i_index < 0 )
449 p_playlist->i_index = p_playlist->i_size - 1;
453 /*****************************************************************************
454 * PlayItem: play current playlist item
455 *****************************************************************************
456 * This function calculates the position of the next playlist item, depending
457 * on the playlist course mode (forward, backward, random...).
458 *****************************************************************************/
459 static void PlayItem( playlist_t *p_playlist )
461 if( p_playlist->i_index == -1 )
463 if( p_playlist->i_size == 0 )
468 SkipItem( p_playlist, 1 );
471 msg_Dbg( p_playlist, "creating new input thread" );
472 p_playlist->p_input = input_CreateThread( p_playlist,
473 p_playlist->pp_items[p_playlist->i_index], NULL );
476 /*****************************************************************************
477 * Poubellize: put an input thread in the trashcan
478 *****************************************************************************
480 *****************************************************************************/
481 static void Poubellize ( playlist_t *p_playlist, input_thread_t *p_input )