/**
* delete an item from a playlist.
*
* \param p_playlist the playlist to remove from.
* \param i_pos the position of the item to remove
* \return returns 0
*/
int playlist_Delete( playlist_t * p_playlist, int i_pos )
{
vlc_value_t val;
/* if i_pos is the current played item, playlist should stop playing it */
if( ( p_playlist->i_status == PLAYLIST_RUNNING) &&
(p_playlist->i_index == i_pos) )
{
playlist_Command( p_playlist, PLAYLIST_STOP, 0 );
}
vlc_mutex_lock( &p_playlist->object_lock );
if( i_pos >= 0 && i_pos < p_playlist->i_size )
{
playlist_item_t *p_item = p_playlist->pp_items[i_pos];
msg_Dbg( p_playlist, "deleting playlist item `%s'",
p_item->input.psz_name );
playlist_ItemDelete( p_item );
if( i_pos <= p_playlist->i_index )
{
p_playlist->i_index--;
}
/* Renumber the playlist */
REMOVE_ELEM( p_playlist->pp_items, p_playlist->i_size, i_pos );
if( p_playlist->i_enabled > 0 ) p_playlist->i_enabled--;
}
vlc_mutex_unlock( &p_playlist->object_lock );
val.b_bool = VLC_TRUE;
var_Set( p_playlist, "intf-change", val );
return 0;
}
/*****************************************************************************
* RunThread: main playlist thread
*****************************************************************************/
static void RunThread ( playlist_t *p_playlist )
{
vlc_object_t *p_obj;
vlc_value_t val;
mtime_t i_vout_destroyed_date = 0;
mtime_t i_sout_destroyed_date = 0;
playlist_item_t *p_autodelete_item = 0;
/* Tell above that we're ready */
vlc_thread_ready( p_playlist );
while( !p_playlist->b_die )
{
vlc_mutex_lock( &p_playlist->object_lock );
/* If there is an input, check that it doesn't need to die. */
if( p_playlist->p_input )
{
/* This input is dead. Remove it ! */
if( p_playlist->p_input->b_dead )
{
input_thread_t *p_input;
p_input = p_playlist->p_input;
p_playlist->p_input = NULL;
/* Release the playlist lock, because we may get stuck
* in input_DestroyThread() for some time. */
vlc_mutex_unlock( &p_playlist->object_lock );
/* Destroy input */
input_DestroyThread( p_input );
/* Unlink current input
* (_after_ input_DestroyThread for vout garbage collector) */
vlc_object_detach( p_input );
/* Destroy object */
vlc_object_destroy( p_input );
i_vout_destroyed_date = 0;
i_sout_destroyed_date = 0;
/* Check for autodeletion */
if( p_autodelete_item )
{
playlist_ItemDelete( p_autodelete_item );
p_autodelete_item = 0;
}
continue;
}
/* This input is dying, let him do */
else if( p_playlist->p_input->b_die )
{
;
}
/* This input has finished, ask him to die ! */
else if( p_playlist->p_input->b_error
|| p_playlist->p_input->b_eof )
{
input_StopThread( p_playlist->p_input );
if( p_playlist->pp_items[p_playlist->i_index]->b_autodeletion )
{
/* This ain't pretty but hey it works */
p_autodelete_item =
p_playlist->pp_items[p_playlist->i_index];
p_playlist->pp_items[p_playlist->i_index] =
playlist_ItemNew( p_playlist,
p_autodelete_item->input.psz_uri, 0);
vlc_mutex_unlock( &p_playlist->object_lock );
p_playlist->i_status = PLAYLIST_STOPPED;
playlist_Delete( p_playlist, p_playlist->i_index );
p_playlist->i_status = PLAYLIST_RUNNING;
vlc_mutex_lock( &p_playlist->object_lock );
}
SkipItem( p_playlist, 1 );
vlc_mutex_unlock( &p_playlist->object_lock );
continue;
}
else if( p_playlist->p_input->i_state != INIT_S )
{
vlc_mutex_unlock( &p_playlist->object_lock );
i_vout_destroyed_date =
ObjectGarbageCollector( p_playlist, VLC_OBJECT_VOUT,
i_vout_destroyed_date );
i_sout_destroyed_date =
ObjectGarbageCollector( p_playlist, VLC_OBJECT_SOUT,
i_sout_destroyed_date );
vlc_mutex_lock( &p_playlist->object_lock );
}
}
else if( p_playlist->i_status != PLAYLIST_STOPPED )
{
/* Start another input. Let's check if that item has
* been forced. In that case, we override random (by not skipping)
* and play-and-stop */
vlc_bool_t b_forced;
var_Get( p_playlist, "prevent-skip", &val );
b_forced = val.b_bool;
if( val.b_bool == VLC_FALSE )
{
SkipItem( p_playlist, 0 );
}
/* Reset forced status */
val.b_bool = VLC_FALSE;
var_Set( p_playlist, "prevent-skip", val );
/* Check for play-and-stop */
var_Get( p_playlist, "play-and-stop", &val );
if( val.b_bool == VLC_FALSE || b_forced == VLC_TRUE )
{
PlayItem( p_playlist );
}
}
else if( p_playlist->i_status == PLAYLIST_STOPPED )
{
vlc_mutex_unlock( &p_playlist->object_lock );
i_sout_destroyed_date =
ObjectGarbageCollector( p_playlist, VLC_OBJECT_SOUT, mdate() );
i_vout_destroyed_date =
ObjectGarbageCollector( p_playlist, VLC_OBJECT_VOUT, mdate() );
vlc_mutex_lock( &p_playlist->object_lock );
}
vlc_mutex_unlock( &p_playlist->object_lock );
msleep( INTF_IDLE_SLEEP );
}
/* If there is an input, kill it */
while( 1 )
{
vlc_mutex_lock( &p_playlist->object_lock );
if( p_playlist->p_input == NULL )
{
vlc_mutex_unlock( &p_playlist->object_lock );
break;
}
if( p_playlist->p_input->b_dead )
{
input_thread_t *p_input;
/* Unlink current input */
p_input = p_playlist->p_input;
p_playlist->p_input = NULL;
vlc_mutex_unlock( &p_playlist->object_lock );
/* Destroy input */
input_DestroyThread( p_input );
/* Unlink current input (_after_ input_DestroyThread for vout
* garbage collector)*/
vlc_object_detach( p_input );
/* Destroy object */
vlc_object_destroy( p_input );
continue;
}
else if( p_playlist->p_input->b_die )
{
/* This input is dying, leave him alone */
;
}
else if( p_playlist->p_input->b_error || p_playlist->p_input->b_eof )
{
input_StopThread( p_playlist->p_input );
vlc_mutex_unlock( &p_playlist->object_lock );
continue;
}
else
{
p_playlist->p_input->b_eof = 1;
}
vlc_mutex_unlock( &p_playlist->object_lock );
msleep( INTF_IDLE_SLEEP );
}
/* close all remaining sout */
while( ( p_obj = vlc_object_find( p_playlist,
VLC_OBJECT_SOUT, FIND_CHILD ) ) )
{
vlc_object_release( p_obj );
sout_DeleteInstance( (sout_instance_t*)p_obj );
}
/* close all remaining vout */
while( ( p_obj = vlc_object_find( p_playlist,
VLC_OBJECT_VOUT, FIND_CHILD ) ) )
{
vlc_object_detach( p_obj );
vlc_object_release( p_obj );
vout_Destroy( (vout_thread_t *)p_obj );
}
}
/**
* Add a playlist item to a given node (in the category view )
*
* \param p_playlist the playlist to insert into
* \param p_item the playlist item to insert
* \param i_view the view for which to add or TODO: ALL_VIEWS
* \param p_parent the parent node
* \param i_mode the mode used when adding
* \param i_pos the possition in the node where to add. If this is
* PLAYLIST_END the item will be added at the end of the node
** \return The id of the playlist item
*/
int playlist_NodeAddItem( playlist_t *p_playlist, playlist_item_t *p_item,
int i_view,playlist_item_t *p_parent,
int i_mode, int i_pos)
{
vlc_value_t val;
int i_position;
playlist_view_t *p_view;
playlist_add_t *p_add = (playlist_add_t *)malloc(sizeof( playlist_add_t));
vlc_mutex_lock( &p_playlist->object_lock );
if ( i_pos == PLAYLIST_END ) i_pos = -1;
/* Sanity checks */
if( !p_parent || p_parent->i_children == -1 )
{
msg_Err( p_playlist, "invalid node" );
}
/*
* CHECK_INSERT : checks if the item is already enqued before
* enqueing it
*/
if ( i_mode & PLAYLIST_CHECK_INSERT )
{
int j;
if ( p_playlist->pp_items )
{
for ( j = 0; j < p_playlist->i_size; j++ )
{
if ( !strcmp( p_playlist->pp_items[j]->input.psz_uri,
p_item->input.psz_uri ) )
{
playlist_ItemDelete( p_item );
vlc_mutex_unlock( &p_playlist->object_lock );
free( p_add );
return -1;
}
}
}
i_mode &= ~PLAYLIST_CHECK_INSERT;
i_mode |= PLAYLIST_APPEND;
}
msg_Dbg( p_playlist, "adding playlist item `%s' ( %s )",
p_item->input.psz_name, p_item->input.psz_uri );
p_item->input.i_id = ++p_playlist->i_last_id;
/* First, add the item at the right position in the item bank */
/* WHY THAT ? */
//i_position = p_playlist->i_index == -1 ? 0 : p_playlist->i_index;
i_position = p_playlist->i_size ;
INSERT_ELEM( p_playlist->pp_items,
p_playlist->i_size,
i_position,
p_item );
INSERT_ELEM( p_playlist->pp_all_items,
p_playlist->i_all_size,
p_playlist->i_all_size,
p_item );
p_playlist->i_enabled ++;
/* TODO: Handle modes */
playlist_NodeInsert( p_playlist, i_view, p_item, p_parent, i_pos );
p_add->i_item = p_item->input.i_id;
p_add->i_node = p_parent->input.i_id;
p_add->i_view = i_view;
val.p_address = p_add;
var_Set( p_playlist, "item-append", val );
/* We update the ALL view directly */
p_view = playlist_ViewFind( p_playlist, VIEW_ALL );
playlist_ItemAddParent( p_item, VIEW_ALL, p_view->p_root );
playlist_ViewUpdate( p_playlist, VIEW_ALL );
/* TODO : Update sorted views*/
if( i_mode & PLAYLIST_GO )
{
p_playlist->request.b_request = VLC_TRUE;
p_playlist->request.i_view = VIEW_CATEGORY;
p_playlist->request.p_node = p_parent;
p_playlist->request.p_item = p_item;
if( p_playlist->p_input )
{
input_StopThread( p_playlist->p_input );
}
p_playlist->status.i_status = PLAYLIST_RUNNING;
}
if( i_mode & PLAYLIST_PREPARSE &&
var_CreateGetBool( p_playlist, "auto-preparse" ) )
{
playlist_PreparseEnqueue( p_playlist, &p_item->input );
}
vlc_mutex_unlock( &p_playlist->object_lock );
val.b_bool = VLC_TRUE;
// var_Set( p_playlist, "intf-change", val );
//
free( p_add );
return p_item->input.i_id;
}
/**
* Deletes an item from a playlist.
*
* This function must be entered without the playlist lock
*
* \param p_playlist the playlist to remove from.
* \param i_id the identifier of the item to delete
* \return returns VLC_SUCCESS or an error
*/
int playlist_Delete( playlist_t * p_playlist, int i_id )
{
int i, i_top, i_bottom;
int i_pos;
vlc_bool_t b_flag = VLC_FALSE;
playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_id );
if( p_item == NULL )
{
return VLC_EGENERIC;
}
if( p_item->i_children > -1 )
{
return playlist_NodeDelete( p_playlist, p_item, VLC_TRUE, VLC_FALSE );
}
var_SetInteger( p_playlist, "item-deleted", i_id );
i_bottom = 0; i_top = p_playlist->i_all_size - 1;
i = i_top / 2;
while( p_playlist->pp_all_items[i]->input.i_id != i_id &&
i_top > i_bottom )
{
if( p_playlist->pp_all_items[i]->input.i_id < i_id )
{
i_bottom = i + 1;
}
else
{
i_top = i - 1;
}
i = i_bottom + ( i_top - i_bottom ) / 2;
}
if( p_playlist->pp_all_items[i]->input.i_id == i_id )
{
REMOVE_ELEM( p_playlist->pp_all_items, p_playlist->i_all_size, i );
}
/* Check if it is the current item */
if( p_playlist->status.p_item == p_item )
{
/* Hack we don't call playlist_Control for lock reasons */
p_playlist->status.i_status = PLAYLIST_STOPPED;
p_playlist->request.b_request = VLC_TRUE;
p_playlist->request.p_item = NULL;
msg_Info( p_playlist, "stopping playback" );
b_flag = VLC_TRUE;
}
/* Get position and update index if needed */
i_pos = playlist_GetPositionById( p_playlist, i_id );
if( i_pos >= 0 && i_pos <= p_playlist->i_index )
{
p_playlist->i_index--;
}
msg_Dbg( p_playlist, "deleting playlist item `%s'",
p_item->input.psz_name );
/* Remove the item from all its parent nodes */
for ( i= 0 ; i < p_item->i_parents ; i++ )
{
playlist_NodeRemoveItem( p_playlist, p_item,
p_item->pp_parents[i]->p_parent );
if( p_item->pp_parents[i]->i_view == VIEW_ALL )
{
p_playlist->i_size--;
}
}
/* TODO : Update views */
if( b_flag == VLC_FALSE )
playlist_ItemDelete( p_item );
else
p_item->i_flags |= PLAYLIST_REMOVE_FLAG;
return VLC_SUCCESS;
}
/**
* Add a playlist item into a playlist
*
* \param p_playlist the playlist to insert into
* \param p_item the playlist item to insert
* \param i_mode the mode used when adding
* \param i_pos the possition in the playlist where to add. If this is
* PLAYLIST_END the item will be added at the end of the playlist
* regardless of it's size
* \return The id of the playlist item
*/
int playlist_AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
int i_mode, int i_pos)
{
vlc_value_t val;
vlc_bool_t b_end = VLC_FALSE;
playlist_view_t *p_view = NULL;
playlist_add_t *p_add = (playlist_add_t *)malloc(sizeof( playlist_add_t));
vlc_mutex_lock( &p_playlist->object_lock );
/*
* CHECK_INSERT : checks if the item is already enqued before
* enqueing it
*/
/* That should not change */
if ( i_mode & PLAYLIST_CHECK_INSERT )
{
int j;
if ( p_playlist->pp_items )
{
for ( j = 0; j < p_playlist->i_size; j++ )
{
if ( !strcmp( p_playlist->pp_items[j]->input.psz_uri,
p_item->input.psz_uri ) )
{
playlist_ItemDelete( p_item );
vlc_mutex_unlock( &p_playlist->object_lock );
return -1;
}
}
}
i_mode &= ~PLAYLIST_CHECK_INSERT;
i_mode |= PLAYLIST_APPEND;
}
msg_Dbg( p_playlist, "adding playlist item `%s' ( %s )",
p_item->input.psz_name, p_item->input.psz_uri );
p_item->input.i_id = ++p_playlist->i_last_id;
/* Do a few boundary checks and allocate space for the item */
if( i_pos == PLAYLIST_END )
{
b_end = VLC_TRUE;
if( i_mode & PLAYLIST_INSERT )
{
i_mode &= ~PLAYLIST_INSERT;
i_mode |= PLAYLIST_APPEND;
}
i_pos = p_playlist->i_size - 1;
}
if( !(i_mode & PLAYLIST_REPLACE)
|| i_pos < 0 || i_pos >= p_playlist->i_size )
{
/* Additional boundary checks */
if( i_mode & PLAYLIST_APPEND )
{
i_pos++;
}
if( i_pos < 0 )
{
i_pos = 0;
}
else if( i_pos > p_playlist->i_size )
{
i_pos = p_playlist->i_size;
}
INSERT_ELEM( p_playlist->pp_items, p_playlist->i_size, i_pos, p_item );
INSERT_ELEM( p_playlist->pp_all_items, p_playlist->i_all_size,
p_playlist->i_all_size, p_item );
p_playlist->i_enabled ++;
/* We update the ALL view directly */
playlist_ViewUpdate( p_playlist, VIEW_ALL );
/* Add the item to the General category */
if( b_end == VLC_TRUE )
{
playlist_NodeAppend( p_playlist, VIEW_CATEGORY, p_item,
p_playlist->p_general );
p_add->i_item = p_item->input.i_id;
p_add->i_node = p_playlist->p_general->input.i_id;
p_add->i_view = VIEW_CATEGORY;
val.p_address = p_add;
var_Set( p_playlist, "item-append", val );
}
else
{
playlist_NodeInsert( p_playlist, VIEW_CATEGORY, p_item,
p_playlist->p_general, i_pos );
}
p_view = playlist_ViewFind( p_playlist, VIEW_ALL );
playlist_ItemAddParent( p_item, VIEW_ALL, p_view->p_root );
/* FIXME : Update sorted views */
if( p_playlist->i_index >= i_pos )
{
p_playlist->i_index++;
}
}
else
{
msg_Err( p_playlist, "Insert mode not implemented" );
}
if( (i_mode & PLAYLIST_GO ) && p_view )
{
p_playlist->request.b_request = VLC_TRUE;
/* FIXME ... */
p_playlist->request.i_view = VIEW_CATEGORY;
p_playlist->request.p_node = p_view->p_root;
p_playlist->request.p_item = p_item;
if( p_playlist->p_input )
{
input_StopThread( p_playlist->p_input );
}
p_playlist->status.i_status = PLAYLIST_RUNNING;
}
if( i_mode & PLAYLIST_PREPARSE &&
var_CreateGetBool( p_playlist, "auto-preparse" ) )
{
playlist_PreparseEnqueue( p_playlist, &p_item->input );
}
vlc_mutex_unlock( &p_playlist->object_lock );
if( b_end == VLC_FALSE )
{
val.b_bool = VLC_TRUE;
var_Set( p_playlist, "intf-change", val );
}
free( p_add );
return p_item->input.i_id;
}
