1 /*****************************************************************************
2 * item.c : Playlist item creation/deletion/add/removal functions
3 *****************************************************************************
4 * Copyright (C) 1999-2007 the VideoLAN team
7 * Authors: Samuel Hocevar <sam@zoy.org>
8 * Clément Stenac <zorglub@videolan.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
28 #include <vlc_common.h>
30 #include <vlc_playlist.h>
32 #include "playlist_internal.h"
34 static void AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
35 playlist_item_t *p_node, int i_mode, int i_pos );
36 static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
38 static void ChangeToNode( playlist_t *p_playlist, playlist_item_t *p_item );
40 static int RecursiveAddIntoParent (
41 playlist_t *p_playlist, playlist_item_t *p_parent,
42 input_item_node_t *p_node, int i_pos, bool b_flat,
43 playlist_item_t **pp_first_leaf );
44 static int RecursiveInsertCopy (
45 playlist_t *p_playlist, playlist_item_t *p_item,
46 playlist_item_t *p_parent, int i_pos, bool b_flat );
48 /*****************************************************************************
49 * An input item has gained subitems (Event Callback)
50 *****************************************************************************/
52 static void input_item_add_subitem_tree ( const vlc_event_t * p_event,
55 input_item_t *p_input = p_event->p_obj;
56 playlist_t *p_playlist = (( playlist_item_t* ) user_data)->p_playlist;
57 input_item_node_t *p_new_root = p_event->u.input_item_subitem_tree_added.p_root;
61 playlist_item_t *p_item =
62 playlist_ItemGetByInput( p_playlist, p_input );
64 assert( p_item != NULL );
66 bool b_current = get_current_status_item( p_playlist ) == p_item;
67 bool b_autostart = var_CreateGetBool( p_playlist, "playlist-autostart" );
68 bool b_stop = p_item->i_flags & PLAYLIST_SUBITEM_STOP_FLAG;
71 p_item->i_flags &= ~PLAYLIST_SUBITEM_STOP_FLAG;
73 /* We will have to flatten the tree out if we are in "the playlist" node and
74 the user setting demands flat playlist */
76 if( !pl_priv(p_playlist)->b_tree ) {
77 playlist_item_t *p_up = p_item;
78 while( p_up->p_parent )
80 if( p_up->p_parent == p_playlist->p_playing )
85 p_up = p_up->p_parent;
91 /* If we have to flatten out, then take the item's position in the parent as
92 insertion point and delete the item */
96 playlist_item_t *p_parent = p_item->p_parent;
97 assert( p_parent != NULL );
100 for( i = 0; i < p_parent->i_children; i++ )
102 if( p_parent->pp_children[i] == p_item )
108 assert( i < p_parent->i_children );
110 playlist_DeleteItem( p_playlist, p_item, true );
116 pos = p_item->i_children >= 0 ? p_item->i_children : 0;
120 "p_item" is the node where sub-items should be inserted,
121 "pos" is the insertion position in that node */
123 int last_pos = playlist_InsertInputItemTree( p_playlist,
129 if( !b_flat ) var_SetAddress( p_playlist, "leaf-to-parent", p_input );
131 //control playback only if it was the current playing item that got subitems
134 if( last_pos == pos || ( b_stop && !b_flat ) || !b_autostart )
136 /* We stop, either because no sub-item was actually created, or some
137 flags/settings want us to do so at this point */
139 playlist_Stop( p_playlist );
144 /* Continue to play, either random or the first new item */
145 playlist_item_t *p_play_item;
147 if( var_GetBool( p_playlist, "random" ) )
150 ((unsigned)vlc_mrand48()) % (last_pos - pos);
152 p_play_item = p_item->pp_children[rand_pos];
156 p_play_item = playlist_GetNextLeaf( p_playlist,
161 char *psz_name = input_item_GetName(p_play_item->p_input);
165 playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
167 get_current_status_node( p_playlist ),
174 /*****************************************************************************
175 * An input item's meta or duration has changed (Event Callback)
176 *****************************************************************************/
177 static void input_item_changed( const vlc_event_t * p_event,
180 playlist_item_t *p_item = user_data;
181 VLC_UNUSED( p_event );
182 var_SetAddress( p_item->p_playlist, "item-change", p_item->p_input );
185 /*****************************************************************************
186 * Listen to vlc_InputItemAddSubItem event
187 *****************************************************************************/
188 static void install_input_item_observer( playlist_item_t * p_item )
190 vlc_event_manager_t * p_em = &p_item->p_input->event_manager;
191 vlc_event_attach( p_em, vlc_InputItemSubItemTreeAdded,
192 input_item_add_subitem_tree, p_item );
193 vlc_event_attach( p_em, vlc_InputItemDurationChanged,
194 input_item_changed, p_item );
195 vlc_event_attach( p_em, vlc_InputItemMetaChanged,
196 input_item_changed, p_item );
197 vlc_event_attach( p_em, vlc_InputItemNameChanged,
198 input_item_changed, p_item );
199 vlc_event_attach( p_em, vlc_InputItemInfoChanged,
200 input_item_changed, p_item );
201 vlc_event_attach( p_em, vlc_InputItemErrorWhenReadingChanged,
202 input_item_changed, p_item );
205 static void uninstall_input_item_observer( playlist_item_t * p_item )
207 vlc_event_manager_t * p_em = &p_item->p_input->event_manager;
208 vlc_event_detach( p_em, vlc_InputItemSubItemTreeAdded,
209 input_item_add_subitem_tree, p_item );
210 vlc_event_detach( p_em, vlc_InputItemMetaChanged,
211 input_item_changed, p_item );
212 vlc_event_detach( p_em, vlc_InputItemDurationChanged,
213 input_item_changed, p_item );
214 vlc_event_detach( p_em, vlc_InputItemNameChanged,
215 input_item_changed, p_item );
216 vlc_event_detach( p_em, vlc_InputItemInfoChanged,
217 input_item_changed, p_item );
218 vlc_event_detach( p_em, vlc_InputItemErrorWhenReadingChanged,
219 input_item_changed, p_item );
222 /*****************************************************************************
223 * Playlist item creation
224 *****************************************************************************/
225 playlist_item_t *playlist_ItemNewFromInput( playlist_t *p_playlist,
226 input_item_t *p_input )
228 playlist_item_t* p_item = malloc( sizeof( playlist_item_t ) );
234 p_item->p_input = p_input;
235 vlc_gc_incref( p_item->p_input );
237 p_item->i_id = ++pl_priv(p_playlist)->i_last_playlist_id;
239 p_item->p_parent = NULL;
240 p_item->i_children = -1;
241 p_item->pp_children = NULL;
243 p_item->p_playlist = p_playlist;
245 install_input_item_observer( p_item );
250 /***************************************************************************
251 * Playlist item destruction
252 ***************************************************************************/
257 * \param p_item item to delete
258 * \return VLC_SUCCESS
260 int playlist_ItemRelease( playlist_item_t *p_item )
263 playlist_t *p_playlist = p_item->p_playlist;
266 /* Surprise, we can't actually do more because we
267 * don't do refcounting, or eauivalent.
268 * Because item are not only accessed by their id
269 * using playlist_item outside the PL_LOCK isn't safe.
270 * Most of the modules does that.
272 * Who wants to add proper memory management? */
273 uninstall_input_item_observer( p_item );
274 ARRAY_APPEND( pl_priv(p_playlist)->items_to_delete, p_item);
281 * Remove an input item when it appears from a root playlist item
282 * \param p_playlist playlist object
283 * \param p_input the input to delete
284 * \param p_root root playlist item
285 * \param b_do_stop must stop or not the playlist
286 * \return VLC_SUCCESS or VLC_EGENERIC
288 static int DeleteFromInput( playlist_t *p_playlist, input_item_t *p_input,
289 playlist_item_t *p_root, bool b_do_stop )
292 playlist_item_t *p_item = playlist_ItemFindFromInputAndRoot(
293 p_playlist, p_input, p_root, false );
294 if( !p_item ) return VLC_EGENERIC;
295 return playlist_DeleteItem( p_playlist, p_item, b_do_stop );
301 * Remove an input item when it appears from a root playlist item
302 * \param p_playlist playlist object
303 * \param p_input the input to delete
304 * \param p_root root playlist item
305 * \param b_locked TRUE if the playlist is locked
306 * \return VLC_SUCCESS or VLC_EGENERIC
308 int playlist_DeleteFromInputInParent( playlist_t *p_playlist,
309 input_item_t *p_item,
310 playlist_item_t *p_root, bool b_locked )
313 PL_LOCK_IF( !b_locked );
314 i_ret = DeleteFromInput( p_playlist, p_item, p_root, true );
315 PL_UNLOCK_IF( !b_locked );
322 * Search anywhere in playlist for an an input item and delete it
323 * \param p_playlist playlist object
324 * \param p_input the input to delete
325 * \param b_locked TRUE if the playlist is locked
326 * \return VLC_SUCCESS or VLC_ENOITEM
328 int playlist_DeleteFromInput( playlist_t *p_playlist, input_item_t *p_input,
332 PL_LOCK_IF( !b_locked );
333 i_ret = DeleteFromInput( p_playlist, p_input,
334 p_playlist->p_root, true );
335 PL_UNLOCK_IF( !b_locked );
336 return ( i_ret == VLC_SUCCESS ? VLC_SUCCESS : VLC_ENOITEM );
342 * \param p_playlist playlist object
343 * \param b_locked TRUE if the playlist is locked
346 void playlist_Clear( playlist_t * p_playlist, bool b_locked )
348 PL_LOCK_IF( !b_locked );
349 playlist_NodeEmpty( p_playlist, p_playlist->p_playing, true );
350 PL_UNLOCK_IF( !b_locked );
354 * Delete playlist item
356 * Remove a playlist item from the playlist, given its id
357 * This function is to be used only by the playlist
358 * \param p_playlist playlist object
359 * \param i_id id of the item do delete
360 * \return VLC_SUCCESS or an error
362 int playlist_DeleteFromItemId( playlist_t *p_playlist, int i_id )
365 playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_id );
366 if( !p_item ) return VLC_EGENERIC;
367 return playlist_DeleteItem( p_playlist, p_item, true );
370 /***************************************************************************
371 * Playlist item addition
372 ***************************************************************************/
376 * Add an item to the playlist or the media library
377 * \param p_playlist the playlist to add into
378 * \param psz_uri the mrl to add to the playlist
379 * \param psz_name a text giving a name or description of this item
380 * \param i_mode the mode used when adding
381 * \param i_pos the position in the playlist where to add. If this is
382 * PLAYLIST_END the item will be added at the end of the playlist
383 * regardless of its size
384 * \param b_playlist TRUE for playlist, FALSE for media library
385 * \param b_locked TRUE if the playlist is locked
386 * \return VLC_SUCCESS or a VLC error code
388 int playlist_Add( playlist_t *p_playlist, const char *psz_uri,
389 const char *psz_name, int i_mode, int i_pos,
390 bool b_playlist, bool b_locked )
392 return playlist_AddExt( p_playlist, psz_uri, psz_name,
393 i_mode, i_pos, -1, 0, NULL, 0, b_playlist, b_locked );
397 * Add a MRL into the playlist or the media library, duration and options given
399 * \param p_playlist the playlist to add into
400 * \param psz_uri the mrl to add to the playlist
401 * \param psz_name a text giving a name or description of this item
402 * \param i_mode the mode used when adding
403 * \param i_pos the position in the playlist where to add. If this is
404 * PLAYLIST_END the item will be added at the end of the playlist
405 * regardless of its size
406 * \param i_duration length of the item in milliseconds.
407 * \param i_options the number of options
408 * \param ppsz_options an array of options
409 * \param i_option_flags options flags
410 * \param b_playlist TRUE for playlist, FALSE for media library
411 * \param b_locked TRUE if the playlist is locked
412 * \return VLC_SUCCESS or a VLC error code
414 int playlist_AddExt( playlist_t *p_playlist, const char * psz_uri,
415 const char *psz_name, int i_mode, int i_pos,
417 int i_options, const char *const *ppsz_options,
418 unsigned i_option_flags,
419 bool b_playlist, bool b_locked )
422 input_item_t *p_input;
424 p_input = input_item_NewExt( p_playlist, psz_uri, psz_name,
425 i_options, ppsz_options, i_option_flags,
427 if( p_input == NULL )
429 i_ret = playlist_AddInput( p_playlist, p_input, i_mode, i_pos, b_playlist,
431 vlc_gc_decref( p_input );
436 * Add an input item to the playlist node
438 * \param p_playlist the playlist to add into
439 * \param p_input the input item to add
440 * \param i_mode the mode used when adding
441 * \param i_pos the position in the playlist where to add. If this is
442 * PLAYLIST_END the item will be added at the end of the playlist
443 * regardless of its size
444 * \param b_playlist TRUE for playlist, FALSE for media library
445 * \param b_locked TRUE if the playlist is locked
446 * \return VLC_SUCCESS or VLC_ENOMEM or VLC_EGENERIC
448 int playlist_AddInput( playlist_t* p_playlist, input_item_t *p_input,
449 int i_mode, int i_pos, bool b_playlist,
452 playlist_item_t *p_item;
453 if( p_playlist->b_die ) return VLC_EGENERIC;
454 if( !pl_priv(p_playlist)->b_doing_ml )
455 PL_DEBUG( "adding item `%s' ( %s )", p_input->psz_name,
458 PL_LOCK_IF( !b_locked );
460 p_item = playlist_ItemNewFromInput( p_playlist, p_input );
461 if( p_item == NULL ) return VLC_ENOMEM;
462 AddItem( p_playlist, p_item,
463 b_playlist ? p_playlist->p_playing :
464 p_playlist->p_media_library , i_mode, i_pos );
466 GoAndPreparse( p_playlist, i_mode, p_item );
468 PL_UNLOCK_IF( !b_locked );
473 * Add an input item to a given node
475 * \param p_playlist the playlist to add into
476 * \param p_input the input item to add
477 * \param p_parent the parent item to add into
478 * \param i_mode the mode used when addin
479 * \param i_pos the position in the playlist where to add. If this is
480 * PLAYLIST_END the item will be added at the end of the playlist
481 * regardless of its size
482 * \param b_locked TRUE if the playlist is locked
483 * \return the new playlist item
485 playlist_item_t * playlist_NodeAddInput( playlist_t *p_playlist,
486 input_item_t *p_input,
487 playlist_item_t *p_parent,
488 int i_mode, int i_pos,
491 playlist_item_t *p_item;
493 assert( p_parent && p_parent->i_children != -1 );
495 if( p_playlist->b_die )
497 PL_LOCK_IF( !b_locked );
499 p_item = playlist_ItemNewFromInput( p_playlist, p_input );
500 if( p_item == NULL ) return NULL;
501 AddItem( p_playlist, p_item, p_parent, i_mode, i_pos );
503 GoAndPreparse( p_playlist, i_mode, p_item );
505 PL_UNLOCK_IF( !b_locked );
511 * Copy an item (and all its children, if any) into another node
513 * \param p_playlist the playlist to operate on
514 * \param p_item the playlist item to copy
515 * \param p_parent the parent item to copy into
516 * \param i_pos the position in the parent item for the new copy;
517 * if this is PLAYLIST_END, the copy is appended after all
519 * \return the position in parent item just behind the last new item inserted
521 int playlist_NodeAddCopy (
522 playlist_t *p_playlist, playlist_item_t *p_item,
523 playlist_item_t *p_parent, int i_pos )
526 assert( p_parent != NULL && p_item != NULL );
527 assert( p_parent->i_children > -1 );
529 if( i_pos == PLAYLIST_END ) i_pos = p_parent->i_children;
533 playlist_item_t *p_up = p_parent;
536 if( p_up == p_playlist->p_playing )
537 if( !pl_priv(p_playlist)->b_tree ) b_flat = true;
539 /* TODO: We don't support copying a node into itself (yet),
540 because we insert items as we copy. Instead, we should copy
541 all items first and then insert. */
543 p_up = p_up->p_parent;
546 return RecursiveInsertCopy( p_playlist, p_item, p_parent, i_pos, b_flat );
550 * Insert a tree of input items into a given playlist node
552 * \param p_playlist the playlist to insert into
553 * \param p_parent the receiving playlist node (can be an item)
554 * \param p_node the root of input item tree,
555 only it's contents will be inserted
556 * \param i_pos the position in the playlist where to insert. If this is
557 * PLAYLIST_END the items will be added at the end of the playlist
558 * regardless of its size
559 * \param b_flat TRUE if the new tree contents should be flattened into a list
560 * \return the first new leaf inserted (in playing order)
562 int playlist_InsertInputItemTree (
563 playlist_t *p_playlist, playlist_item_t *p_parent,
564 input_item_node_t *p_node, int i_pos, bool b_flat )
566 playlist_item_t *p_first_leaf = NULL;
567 int i = RecursiveAddIntoParent ( p_playlist, p_parent, p_node, i_pos, b_flat, &p_first_leaf );
572 /*****************************************************************************
573 * Playlist item misc operations
574 *****************************************************************************/
577 * Find an item within a root, given its input id.
579 * \param p_playlist the playlist object
580 * \param p_item the input item
581 * \param p_root root playlist item
582 * \param b_items_only TRUE if we want the item himself
583 * \return the first found item, or NULL if not found
585 playlist_item_t *playlist_ItemFindFromInputAndRoot( playlist_t *p_playlist,
586 input_item_t *p_item,
587 playlist_item_t *p_root,
591 for( i = 0 ; i< p_root->i_children ; i++ )
593 if( ( b_items_only ? p_root->pp_children[i]->i_children == -1 : 1 ) &&
594 p_root->pp_children[i]->p_input == p_item )
596 return p_root->pp_children[i];
598 else if( p_root->pp_children[i]->i_children >= 0 )
600 playlist_item_t *p_search =
601 playlist_ItemFindFromInputAndRoot( p_playlist, p_item,
602 p_root->pp_children[i],
604 if( p_search ) return p_search;
611 static int ItemIndex ( playlist_item_t *p_item )
613 for( int i = 0; i < p_item->p_parent->i_children; i++ )
614 if( p_item->p_parent->pp_children[i] == p_item ) return i;
621 * This function must be entered with the playlist lock
623 * \param p_playlist the playlist
624 * \param p_item the item to move
625 * \param p_node the new parent of the item
626 * \param i_newpos the new position under this new parent
627 * \return VLC_SUCCESS or an error
629 int playlist_TreeMove( playlist_t * p_playlist, playlist_item_t *p_item,
630 playlist_item_t *p_node, int i_newpos )
634 if( p_node->i_children == -1 ) return VLC_EGENERIC;
636 playlist_item_t *p_detach = p_item->p_parent;
637 int i_index = ItemIndex( p_item );
639 REMOVE_ELEM( p_detach->pp_children, p_detach->i_children, i_index );
641 if( p_detach == p_node && i_index < i_newpos )
644 INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
645 p_item->p_parent = p_node;
647 pl_priv( p_playlist )->b_reset_currently_playing = true;
648 vlc_cond_signal( &pl_priv( p_playlist )->signal );
653 * Moves an array of items
655 * This function must be entered with the playlist lock
657 * \param p_playlist the playlist
658 * \param i_items the number of indexes to move
659 * \param pp_items the array of indexes to move
660 * \param p_node the target node
661 * \param i_newpos the target position under this node
662 * \return VLC_SUCCESS or an error
664 int playlist_TreeMoveMany( playlist_t *p_playlist,
665 int i_items, playlist_item_t **pp_items,
666 playlist_item_t *p_node, int i_newpos )
670 if ( p_node->i_children == -1 ) return VLC_EGENERIC;
673 for( i = 0; i < i_items; i++ )
675 playlist_item_t *p_item = pp_items[i];
676 int i_index = ItemIndex( p_item );
677 playlist_item_t *p_parent = p_item->p_parent;
678 REMOVE_ELEM( p_parent->pp_children, p_parent->i_children, i_index );
679 if ( p_parent == p_node && i_index < i_newpos ) i_newpos--;
681 for( i = i_items - 1; i >= 0; i-- )
683 playlist_item_t *p_item = pp_items[i];
684 INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
685 p_item->p_parent = p_node;
688 pl_priv( p_playlist )->b_reset_currently_playing = true;
689 vlc_cond_signal( &pl_priv( p_playlist )->signal );
694 * Send a notification that an item has been added to a node
696 * \param p_playlist the playlist object
697 * \param i_item_id id of the item added
698 * \param i_node_id id of the node in wich the item was added
699 * \param b_signal TRUE if the function must send a signal
702 void playlist_SendAddNotify( playlist_t *p_playlist, int i_item_id,
703 int i_node_id, bool b_signal )
705 playlist_private_t *p_sys = pl_priv(p_playlist);
708 p_sys->b_reset_currently_playing = true;
710 vlc_cond_signal( &p_sys->signal );
713 add.i_item = i_item_id;
714 add.i_node = i_node_id;
717 val.p_address = &add;
719 var_Set( p_playlist, "playlist-item-append", val );
722 /***************************************************************************
723 * The following functions are local
724 ***************************************************************************/
726 /* Enqueue an item for preparsing, and play it, if needed */
727 static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
728 playlist_item_t *p_item )
731 if( (i_mode & PLAYLIST_GO ) )
733 pl_priv(p_playlist)->request.b_request = true;
734 pl_priv(p_playlist)->request.i_skip = 0;
735 pl_priv(p_playlist)->request.p_item = p_item;
736 if( pl_priv(p_playlist)->p_input )
737 input_Stop( pl_priv(p_playlist)->p_input, true );
738 pl_priv(p_playlist)->request.i_status = PLAYLIST_RUNNING;
739 vlc_cond_signal( &pl_priv(p_playlist)->signal );
741 /* Preparse if no artist/album info, and hasn't been preparsed allready
742 and if user has some preparsing option (auto-preparse variable)
744 char *psz_artist = input_item_GetArtist( p_item->p_input );
745 char *psz_album = input_item_GetAlbum( p_item->p_input );
746 if( pl_priv(p_playlist)->b_auto_preparse &&
747 input_item_IsPreparsed( p_item->p_input ) == false &&
748 ( EMPTY_STR( psz_artist ) || ( EMPTY_STR( psz_album ) ) )
750 playlist_PreparseEnqueue( p_playlist, p_item->p_input );
755 /* Add the playlist item to the requested node and fire a notification */
756 static void AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
757 playlist_item_t *p_node, int i_mode, int i_pos )
760 ARRAY_APPEND(p_playlist->items, p_item);
761 ARRAY_APPEND(p_playlist->all_items, p_item);
763 if( i_pos == PLAYLIST_END )
764 playlist_NodeAppend( p_playlist, p_item, p_node );
766 playlist_NodeInsert( p_playlist, p_item, p_node, i_pos );
768 if( !pl_priv(p_playlist)->b_doing_ml )
769 playlist_SendAddNotify( p_playlist, p_item->i_id, p_node->i_id,
770 !( i_mode & PLAYLIST_NO_REBUILD ) );
773 /* Actually convert an item to a node */
774 static void ChangeToNode( playlist_t *p_playlist, playlist_item_t *p_item )
777 if( p_item->i_children != -1 ) return;
779 p_item->i_children = 0;
781 input_item_t *p_input = p_item->p_input;
782 vlc_mutex_lock( &p_input->lock );
783 p_input->i_type = ITEM_TYPE_NODE;
784 vlc_mutex_unlock( &p_input->lock );
786 var_SetAddress( p_playlist, "item-change", p_item->p_input );
788 /* Remove it from the array of available items */
789 ARRAY_BSEARCH( p_playlist->items,->i_id, int, p_item->i_id, i );
791 ARRAY_REMOVE( p_playlist->items, i );
794 /* Do the actual removal */
795 int playlist_DeleteItem( playlist_t * p_playlist, playlist_item_t *p_item,
799 return playlist_NodeDelete( p_playlist, p_item, true, false );
802 int i_id = p_item->i_id;
805 if( p_item->i_children > -1 )
807 return playlist_NodeDelete( p_playlist, p_item, true, false );
810 pl_priv(p_playlist)->b_reset_currently_playing = true;
811 var_SetInteger( p_playlist, "playlist-item-deleted", i_id );
813 /* Remove the item from the bank */
814 ARRAY_BSEARCH( p_playlist->all_items,->i_id, int, i_id, i );
816 ARRAY_REMOVE( p_playlist->all_items, i );
818 ARRAY_BSEARCH( p_playlist->items,->i_id, int, i_id, i );
820 ARRAY_REMOVE( p_playlist->items, i );
822 /* Check if it is the current item */
823 if( get_current_status_item( p_playlist ) == p_item )
825 /* Stop it if we have to */
828 playlist_Control( p_playlist, PLAYLIST_STOP, pl_Locked );
829 msg_Info( p_playlist, "stopping playback" );
831 /* In any case, this item can't be the next one to be played ! */
832 set_current_status_item( p_playlist, NULL );
835 ARRAY_BSEARCH( p_playlist->current,->i_id, int, i_id, i );
837 ARRAY_REMOVE( p_playlist->current, i );
839 PL_DEBUG( "deleting item `%s'", p_item->p_input->psz_name );
841 /* Remove the item from its parent */
842 playlist_NodeRemoveItem( p_playlist, p_item, p_item->p_parent );
844 playlist_ItemRelease( p_item );
850 static int RecursiveAddIntoParent (
851 playlist_t *p_playlist, playlist_item_t *p_parent,
852 input_item_node_t *p_node, int i_pos, bool b_flat,
853 playlist_item_t **pp_first_leaf )
855 *pp_first_leaf = NULL;
857 if( p_parent->i_children == -1 ) ChangeToNode( p_playlist, p_parent );
859 if( i_pos == PLAYLIST_END ) i_pos = p_parent->i_children;
861 for( int i = 0; i < p_node->i_children; i++ )
863 input_item_node_t *p_child_node = p_node->pp_children[i];
865 playlist_item_t *p_new_item = NULL;
866 bool b_children = p_child_node->i_children > 0;
868 //Create the playlist item represented by input node, if allowed.
869 if( !(b_flat && b_children) )
871 p_new_item = playlist_NodeAddInput( p_playlist,
872 p_child_node->p_item,
874 PLAYLIST_INSERT, i_pos,
876 if( !p_new_item ) return i_pos;
880 //Recurse if any children
883 //Substitute p_new_item for first child leaf
884 //(If flat, continue counting from current position)
885 int i_last_pos = RecursiveAddIntoParent(
887 p_new_item ? p_new_item : p_parent,
889 ( b_flat ? i_pos : 0 ),
892 //If flat, take position after recursion as current position
893 if( b_flat ) i_pos = i_last_pos;
896 assert( p_new_item != NULL );
897 if( i == 0 ) *pp_first_leaf = p_new_item;
902 static int RecursiveInsertCopy (
903 playlist_t *p_playlist, playlist_item_t *p_item,
904 playlist_item_t *p_parent, int i_pos, bool b_flat )
907 assert( p_parent != NULL && p_item != NULL );
909 if( p_item == p_parent ) return i_pos;
911 input_item_t *p_input = p_item->p_input;
913 if( !(p_item->i_children != -1 && b_flat) )
915 input_item_t *p_new_input = input_item_Copy( VLC_OBJECT(p_playlist),
917 if( !p_new_input ) return i_pos;
919 playlist_item_t *p_new_item = NULL;
920 if( p_item->i_children == -1 )
921 p_new_item = playlist_NodeAddInput( p_playlist, p_new_input,
922 p_parent, PLAYLIST_INSERT, i_pos,
925 p_new_item = playlist_NodeCreate( p_playlist, NULL,
926 p_parent, i_pos, 0, p_new_input );
927 vlc_gc_decref( p_new_input );
928 if( !p_new_item ) return i_pos;
932 if( p_new_item->i_children != -1 )
933 p_parent = p_new_item;
936 for( int i = 0; i < p_item->i_children; i++ )
939 i_pos = RecursiveInsertCopy( p_playlist, p_item->pp_children[i],
940 p_parent, i_pos, true );
942 RecursiveInsertCopy( p_playlist, p_item->pp_children[i],
943 p_parent, p_parent->i_children, false );