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_GetBool( 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_SetInteger( p_playlist
, "leaf-to-parent", p_item
->i_id
);
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
= p_item
->pp_children
[pos
];
157 /* NOTE: this is a work around the general bug:
158 if node-to-be-played contains sub-nodes, then second instead
159 of first leaf starts playing (only in case the leafs have just
160 been instered and playlist has not yet been rebuilt.)
162 while( p_play_item
->i_children
> 0 )
163 p_play_item
= p_play_item
->pp_children
[0];
166 playlist_Control( p_playlist
, PLAYLIST_VIEWPLAY
,
168 get_current_status_node( p_playlist
),
175 /*****************************************************************************
176 * An input item's meta or duration has changed (Event Callback)
177 *****************************************************************************/
178 static void input_item_changed( const vlc_event_t
* p_event
,
181 playlist_item_t
*p_item
= user_data
;
182 VLC_UNUSED( p_event
);
183 var_SetAddress( p_item
->p_playlist
, "item-change", p_item
->p_input
);
186 /*****************************************************************************
187 * Listen to vlc_InputItemAddSubItem event
188 *****************************************************************************/
189 static void install_input_item_observer( playlist_item_t
* p_item
)
191 vlc_event_manager_t
* p_em
= &p_item
->p_input
->event_manager
;
192 vlc_event_attach( p_em
, vlc_InputItemSubItemTreeAdded
,
193 input_item_add_subitem_tree
, p_item
);
194 vlc_event_attach( p_em
, vlc_InputItemDurationChanged
,
195 input_item_changed
, p_item
);
196 vlc_event_attach( p_em
, vlc_InputItemMetaChanged
,
197 input_item_changed
, p_item
);
198 vlc_event_attach( p_em
, vlc_InputItemNameChanged
,
199 input_item_changed
, p_item
);
200 vlc_event_attach( p_em
, vlc_InputItemInfoChanged
,
201 input_item_changed
, p_item
);
202 vlc_event_attach( p_em
, vlc_InputItemErrorWhenReadingChanged
,
203 input_item_changed
, p_item
);
206 static void uninstall_input_item_observer( playlist_item_t
* p_item
)
208 vlc_event_manager_t
* p_em
= &p_item
->p_input
->event_manager
;
209 vlc_event_detach( p_em
, vlc_InputItemSubItemTreeAdded
,
210 input_item_add_subitem_tree
, p_item
);
211 vlc_event_detach( p_em
, vlc_InputItemMetaChanged
,
212 input_item_changed
, p_item
);
213 vlc_event_detach( p_em
, vlc_InputItemDurationChanged
,
214 input_item_changed
, p_item
);
215 vlc_event_detach( p_em
, vlc_InputItemNameChanged
,
216 input_item_changed
, p_item
);
217 vlc_event_detach( p_em
, vlc_InputItemInfoChanged
,
218 input_item_changed
, p_item
);
219 vlc_event_detach( p_em
, vlc_InputItemErrorWhenReadingChanged
,
220 input_item_changed
, p_item
);
223 /*****************************************************************************
224 * Playlist item creation
225 *****************************************************************************/
226 playlist_item_t
*playlist_ItemNewFromInput( playlist_t
*p_playlist
,
227 input_item_t
*p_input
)
229 playlist_item_t
* p_item
= malloc( sizeof( playlist_item_t
) );
235 p_item
->p_input
= p_input
;
236 vlc_gc_incref( p_item
->p_input
);
238 p_item
->i_id
= ++pl_priv(p_playlist
)->i_last_playlist_id
;
240 p_item
->p_parent
= NULL
;
241 p_item
->i_children
= -1;
242 p_item
->pp_children
= NULL
;
244 p_item
->p_playlist
= p_playlist
;
246 install_input_item_observer( p_item
);
251 /***************************************************************************
252 * Playlist item destruction
253 ***************************************************************************/
258 * \param p_item item to delete
259 * \return VLC_SUCCESS
261 int playlist_ItemRelease( playlist_item_t
*p_item
)
264 playlist_t
*p_playlist
= p_item
->p_playlist
;
267 /* Surprise, we can't actually do more because we
268 * don't do refcounting, or eauivalent.
269 * Because item are not only accessed by their id
270 * using playlist_item outside the PL_LOCK isn't safe.
271 * Most of the modules does that.
273 * Who wants to add proper memory management? */
274 uninstall_input_item_observer( p_item
);
275 ARRAY_APPEND( pl_priv(p_playlist
)->items_to_delete
, p_item
);
282 * Remove an input item when it appears from a root playlist item
283 * \param p_playlist playlist object
284 * \param p_input the input to delete
285 * \param p_root root playlist item
286 * \param b_do_stop must stop or not the playlist
287 * \return VLC_SUCCESS or VLC_EGENERIC
289 static int DeleteFromInput( playlist_t
*p_playlist
, input_item_t
*p_input
,
290 playlist_item_t
*p_root
, bool b_do_stop
)
293 playlist_item_t
*p_item
= playlist_ItemFindFromInputAndRoot(
294 p_playlist
, p_input
, p_root
, false );
295 if( !p_item
) return VLC_EGENERIC
;
296 return playlist_DeleteItem( p_playlist
, p_item
, b_do_stop
);
302 * Remove an input item when it appears from a root playlist item
303 * \param p_playlist playlist object
304 * \param p_input the input to delete
305 * \param p_root root playlist item
306 * \param b_locked TRUE if the playlist is locked
307 * \return VLC_SUCCESS or VLC_EGENERIC
309 int playlist_DeleteFromInputInParent( playlist_t
*p_playlist
,
310 input_item_t
*p_item
,
311 playlist_item_t
*p_root
, bool b_locked
)
314 PL_LOCK_IF( !b_locked
);
315 i_ret
= DeleteFromInput( p_playlist
, p_item
, p_root
, true );
316 PL_UNLOCK_IF( !b_locked
);
323 * Search anywhere in playlist for an an input item and delete it
324 * \param p_playlist playlist object
325 * \param p_input the input to delete
326 * \param b_locked TRUE if the playlist is locked
327 * \return VLC_SUCCESS or VLC_ENOITEM
329 int playlist_DeleteFromInput( playlist_t
*p_playlist
, input_item_t
*p_input
,
333 PL_LOCK_IF( !b_locked
);
334 i_ret
= DeleteFromInput( p_playlist
, p_input
,
335 p_playlist
->p_root
, true );
336 PL_UNLOCK_IF( !b_locked
);
337 return ( i_ret
== VLC_SUCCESS
? VLC_SUCCESS
: VLC_ENOITEM
);
343 * \param p_playlist playlist object
344 * \param b_locked TRUE if the playlist is locked
347 void playlist_Clear( playlist_t
* p_playlist
, bool b_locked
)
349 PL_LOCK_IF( !b_locked
);
350 playlist_NodeEmpty( p_playlist
, p_playlist
->p_playing
, true );
351 PL_UNLOCK_IF( !b_locked
);
355 * Delete playlist item
357 * Remove a playlist item from the playlist, given its id
358 * This function is to be used only by the playlist
359 * \param p_playlist playlist object
360 * \param i_id id of the item do delete
361 * \return VLC_SUCCESS or an error
363 int playlist_DeleteFromItemId( playlist_t
*p_playlist
, int i_id
)
366 playlist_item_t
*p_item
= playlist_ItemGetById( p_playlist
, i_id
);
367 if( !p_item
) return VLC_EGENERIC
;
368 return playlist_DeleteItem( p_playlist
, p_item
, true );
371 /***************************************************************************
372 * Playlist item addition
373 ***************************************************************************/
377 * Add an item to the playlist or the media library
378 * \param p_playlist the playlist to add into
379 * \param psz_uri the mrl to add to the playlist
380 * \param psz_name a text giving a name or description of this item
381 * \param i_mode the mode used when adding
382 * \param i_pos the position in the playlist where to add. If this is
383 * PLAYLIST_END the item will be added at the end of the playlist
384 * regardless of its size
385 * \param b_playlist TRUE for playlist, FALSE for media library
386 * \param b_locked TRUE if the playlist is locked
387 * \return VLC_SUCCESS or a VLC error code
389 int playlist_Add( playlist_t
*p_playlist
, const char *psz_uri
,
390 const char *psz_name
, int i_mode
, int i_pos
,
391 bool b_playlist
, bool b_locked
)
393 return playlist_AddExt( p_playlist
, psz_uri
, psz_name
,
394 i_mode
, i_pos
, -1, 0, NULL
, 0, b_playlist
, b_locked
);
398 * Add a MRL into the playlist or the media library, duration and options given
400 * \param p_playlist the playlist to add into
401 * \param psz_uri the mrl to add to the playlist
402 * \param psz_name a text giving a name or description of this item
403 * \param i_mode the mode used when adding
404 * \param i_pos the position in the playlist where to add. If this is
405 * PLAYLIST_END the item will be added at the end of the playlist
406 * regardless of its size
407 * \param i_duration length of the item in milliseconds.
408 * \param i_options the number of options
409 * \param ppsz_options an array of options
410 * \param i_option_flags options flags
411 * \param b_playlist TRUE for playlist, FALSE for media library
412 * \param b_locked TRUE if the playlist is locked
413 * \return VLC_SUCCESS or a VLC error code
415 int playlist_AddExt( playlist_t
*p_playlist
, const char * psz_uri
,
416 const char *psz_name
, int i_mode
, int i_pos
,
418 int i_options
, const char *const *ppsz_options
,
419 unsigned i_option_flags
,
420 bool b_playlist
, bool b_locked
)
423 input_item_t
*p_input
;
425 p_input
= input_item_NewExt( psz_uri
, psz_name
,
426 i_options
, ppsz_options
, i_option_flags
,
428 if( p_input
== NULL
)
430 i_ret
= playlist_AddInput( p_playlist
, p_input
, i_mode
, i_pos
, b_playlist
,
432 vlc_gc_decref( p_input
);
437 * Add an input item to the playlist node
439 * \param p_playlist the playlist to add into
440 * \param p_input the input item to add
441 * \param i_mode the mode used when adding
442 * \param i_pos the position in the playlist where to add. If this is
443 * PLAYLIST_END the item will be added at the end of the playlist
444 * regardless of its size
445 * \param b_playlist TRUE for playlist, FALSE for media library
446 * \param b_locked TRUE if the playlist is locked
447 * \return VLC_SUCCESS or VLC_ENOMEM or VLC_EGENERIC
449 int playlist_AddInput( playlist_t
* p_playlist
, input_item_t
*p_input
,
450 int i_mode
, int i_pos
, bool b_playlist
,
453 playlist_item_t
*p_item
;
454 if( p_playlist
->b_die
) return VLC_EGENERIC
;
455 if( !pl_priv(p_playlist
)->b_doing_ml
)
456 PL_DEBUG( "adding item `%s' ( %s )", p_input
->psz_name
,
459 PL_LOCK_IF( !b_locked
);
461 p_item
= playlist_ItemNewFromInput( p_playlist
, p_input
);
462 if( p_item
== NULL
) return VLC_ENOMEM
;
463 AddItem( p_playlist
, p_item
,
464 b_playlist
? p_playlist
->p_playing
:
465 p_playlist
->p_media_library
, i_mode
, i_pos
);
467 GoAndPreparse( p_playlist
, i_mode
, p_item
);
469 PL_UNLOCK_IF( !b_locked
);
474 * Add an input item to a given node
476 * \param p_playlist the playlist to add into
477 * \param p_input the input item to add
478 * \param p_parent the parent item to add into
479 * \param i_mode the mode used when addin
480 * \param i_pos the position in the playlist where to add. If this is
481 * PLAYLIST_END the item will be added at the end of the playlist
482 * regardless of its size
483 * \param b_locked TRUE if the playlist is locked
484 * \return the new playlist item
486 playlist_item_t
* playlist_NodeAddInput( playlist_t
*p_playlist
,
487 input_item_t
*p_input
,
488 playlist_item_t
*p_parent
,
489 int i_mode
, int i_pos
,
492 playlist_item_t
*p_item
;
494 assert( p_parent
&& p_parent
->i_children
!= -1 );
496 if( p_playlist
->b_die
)
498 PL_LOCK_IF( !b_locked
);
500 p_item
= playlist_ItemNewFromInput( p_playlist
, p_input
);
501 if( p_item
== NULL
) return NULL
;
502 AddItem( p_playlist
, p_item
, p_parent
, i_mode
, i_pos
);
504 GoAndPreparse( p_playlist
, i_mode
, p_item
);
506 PL_UNLOCK_IF( !b_locked
);
512 * Copy an item (and all its children, if any) into another node
514 * \param p_playlist the playlist to operate on
515 * \param p_item the playlist item to copy
516 * \param p_parent the parent item to copy into
517 * \param i_pos the position in the parent item for the new copy;
518 * if this is PLAYLIST_END, the copy is appended after all
520 * \return the position in parent item just behind the last new item inserted
522 int playlist_NodeAddCopy (
523 playlist_t
*p_playlist
, playlist_item_t
*p_item
,
524 playlist_item_t
*p_parent
, int i_pos
)
527 assert( p_parent
!= NULL
&& p_item
!= NULL
);
528 assert( p_parent
->i_children
> -1 );
530 if( i_pos
== PLAYLIST_END
) i_pos
= p_parent
->i_children
;
534 playlist_item_t
*p_up
= p_parent
;
537 if( p_up
== p_playlist
->p_playing
)
538 if( !pl_priv(p_playlist
)->b_tree
) b_flat
= true;
540 /* TODO: We don't support copying a node into itself (yet),
541 because we insert items as we copy. Instead, we should copy
542 all items first and then insert. */
544 p_up
= p_up
->p_parent
;
547 return RecursiveInsertCopy( p_playlist
, p_item
, p_parent
, i_pos
, b_flat
);
551 * Insert a tree of input items into a given playlist node
553 * \param p_playlist the playlist to insert into
554 * \param p_parent the receiving playlist node (can be an item)
555 * \param p_node the root of input item tree,
556 only it's contents will be inserted
557 * \param i_pos the position in the playlist where to insert. If this is
558 * PLAYLIST_END the items will be added at the end of the playlist
559 * regardless of its size
560 * \param b_flat TRUE if the new tree contents should be flattened into a list
561 * \return the first new leaf inserted (in playing order)
563 int playlist_InsertInputItemTree (
564 playlist_t
*p_playlist
, playlist_item_t
*p_parent
,
565 input_item_node_t
*p_node
, int i_pos
, bool b_flat
)
567 playlist_item_t
*p_first_leaf
= NULL
;
568 return 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
;
716 var_SetAddress( p_playlist
, "playlist-item-append", &add
);
719 /***************************************************************************
720 * The following functions are local
721 ***************************************************************************/
723 /* Enqueue an item for preparsing, and play it, if needed */
724 static void GoAndPreparse( playlist_t
*p_playlist
, int i_mode
,
725 playlist_item_t
*p_item
)
728 if( (i_mode
& PLAYLIST_GO
) )
730 pl_priv(p_playlist
)->request
.b_request
= true;
731 pl_priv(p_playlist
)->request
.i_skip
= 0;
732 pl_priv(p_playlist
)->request
.p_item
= p_item
;
733 if( pl_priv(p_playlist
)->p_input
)
734 input_Stop( pl_priv(p_playlist
)->p_input
, true );
735 pl_priv(p_playlist
)->request
.i_status
= PLAYLIST_RUNNING
;
736 vlc_cond_signal( &pl_priv(p_playlist
)->signal
);
738 /* Preparse if no artist/album info, and hasn't been preparsed allready
739 and if user has some preparsing option (auto-preparse variable)
741 char *psz_artist
= input_item_GetArtist( p_item
->p_input
);
742 char *psz_album
= input_item_GetAlbum( p_item
->p_input
);
743 if( pl_priv(p_playlist
)->b_auto_preparse
&&
744 input_item_IsPreparsed( p_item
->p_input
) == false &&
745 ( EMPTY_STR( psz_artist
) || ( EMPTY_STR( psz_album
) ) )
747 playlist_PreparseEnqueue( p_playlist
, p_item
->p_input
);
752 /* Add the playlist item to the requested node and fire a notification */
753 static void AddItem( playlist_t
*p_playlist
, playlist_item_t
*p_item
,
754 playlist_item_t
*p_node
, int i_mode
, int i_pos
)
757 ARRAY_APPEND(p_playlist
->items
, p_item
);
758 ARRAY_APPEND(p_playlist
->all_items
, p_item
);
760 if( i_pos
== PLAYLIST_END
)
761 playlist_NodeAppend( p_playlist
, p_item
, p_node
);
763 playlist_NodeInsert( p_playlist
, p_item
, p_node
, i_pos
);
765 if( !pl_priv(p_playlist
)->b_doing_ml
)
766 playlist_SendAddNotify( p_playlist
, p_item
->i_id
, p_node
->i_id
,
767 !( i_mode
& PLAYLIST_NO_REBUILD
) );
770 /* Actually convert an item to a node */
771 static void ChangeToNode( playlist_t
*p_playlist
, playlist_item_t
*p_item
)
774 if( p_item
->i_children
!= -1 ) return;
776 p_item
->i_children
= 0;
778 input_item_t
*p_input
= p_item
->p_input
;
779 vlc_mutex_lock( &p_input
->lock
);
780 p_input
->i_type
= ITEM_TYPE_NODE
;
781 vlc_mutex_unlock( &p_input
->lock
);
783 var_SetAddress( p_playlist
, "item-change", p_item
->p_input
);
785 /* Remove it from the array of available items */
786 ARRAY_BSEARCH( p_playlist
->items
,->i_id
, int, p_item
->i_id
, i
);
788 ARRAY_REMOVE( p_playlist
->items
, i
);
791 /* Do the actual removal */
792 int playlist_DeleteItem( playlist_t
* p_playlist
, playlist_item_t
*p_item
,
796 return playlist_NodeDelete( p_playlist
, p_item
, true, false );
799 static int RecursiveAddIntoParent (
800 playlist_t
*p_playlist
, playlist_item_t
*p_parent
,
801 input_item_node_t
*p_node
, int i_pos
, bool b_flat
,
802 playlist_item_t
**pp_first_leaf
)
804 *pp_first_leaf
= NULL
;
806 if( p_parent
->i_children
== -1 ) ChangeToNode( p_playlist
, p_parent
);
808 if( i_pos
== PLAYLIST_END
) i_pos
= p_parent
->i_children
;
810 for( int i
= 0; i
< p_node
->i_children
; i
++ )
812 input_item_node_t
*p_child_node
= p_node
->pp_children
[i
];
814 playlist_item_t
*p_new_item
= NULL
;
815 bool b_children
= p_child_node
->i_children
> 0;
817 //Create the playlist item represented by input node, if allowed.
818 if( !(b_flat
&& b_children
) )
820 p_new_item
= playlist_NodeAddInput( p_playlist
,
821 p_child_node
->p_item
,
823 PLAYLIST_INSERT
, i_pos
,
825 if( !p_new_item
) return i_pos
;
829 //Recurse if any children
832 //Substitute p_new_item for first child leaf
833 //(If flat, continue counting from current position)
834 int i_last_pos
= RecursiveAddIntoParent(
836 p_new_item
? p_new_item
: p_parent
,
838 ( b_flat
? i_pos
: 0 ),
841 //If flat, take position after recursion as current position
842 if( b_flat
) i_pos
= i_last_pos
;
845 assert( p_new_item
!= NULL
);
846 if( i
== 0 ) *pp_first_leaf
= p_new_item
;
851 static int RecursiveInsertCopy (
852 playlist_t
*p_playlist
, playlist_item_t
*p_item
,
853 playlist_item_t
*p_parent
, int i_pos
, bool b_flat
)
856 assert( p_parent
!= NULL
&& p_item
!= NULL
);
858 if( p_item
== p_parent
) return i_pos
;
860 input_item_t
*p_input
= p_item
->p_input
;
862 if( !(p_item
->i_children
!= -1 && b_flat
) )
864 input_item_t
*p_new_input
= input_item_Copy( p_input
);
865 if( !p_new_input
) return i_pos
;
867 playlist_item_t
*p_new_item
= NULL
;
868 if( p_item
->i_children
== -1 )
869 p_new_item
= playlist_NodeAddInput( p_playlist
, p_new_input
,
870 p_parent
, PLAYLIST_INSERT
, i_pos
,
873 p_new_item
= playlist_NodeCreate( p_playlist
, NULL
,
874 p_parent
, i_pos
, 0, p_new_input
);
875 vlc_gc_decref( p_new_input
);
876 if( !p_new_item
) return i_pos
;
880 if( p_new_item
->i_children
!= -1 )
881 p_parent
= p_new_item
;
884 for( int i
= 0; i
< p_item
->i_children
; i
++ )
887 i_pos
= RecursiveInsertCopy( p_playlist
, p_item
->pp_children
[i
],
888 p_parent
, i_pos
, true );
890 RecursiveInsertCopy( p_playlist
, p_item
->pp_children
[i
],
891 p_parent
, p_parent
->i_children
, false );