git.sesse.net Git - vlc/blob - src/playlist/item.c

   1 /*****************************************************************************
   2  * item.c : Playlist item creation/deletion/add/removal functions
   3  *****************************************************************************
   4  * Copyright (C) 1999-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Clément Stenac <zorglub@videolan.org>
   9  *
  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.
  14  *
  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.
  19  *
  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  *****************************************************************************/
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <vlc_common.h>
  29 #include <assert.h>
  30 #include <vlc_playlist.h>
  31 #include "playlist_internal.h"
  32
  33 static void AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
  34                      playlist_item_t *p_node, int i_mode, int i_pos );
  35 static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
  36                            playlist_item_t * );
  37 static void ChangeToNode( playlist_t *p_playlist, playlist_item_t *p_item );
  38
  39 static int RecursiveAddIntoParent (
  40                 playlist_t *p_playlist, playlist_item_t *p_parent,
  41                 input_item_node_t *p_node, int i_pos, bool b_flat,
  42                 playlist_item_t **pp_first_leaf );
  43
  44 /*****************************************************************************
  45  * An input item has gained subitems (Event Callback)
  46  *****************************************************************************/
  47
  48 static void input_item_add_subitem_tree ( const vlc_event_t * p_event,
  49                                           void * user_data )
  50 {
  51     input_item_t *p_input = p_event->p_obj;
  52     playlist_t *p_playlist = (( playlist_item_t* ) user_data)->p_playlist;
  53     input_item_node_t *p_new_root = p_event->u.input_item_subitem_tree_added.p_root;
  54
  55     PL_LOCK;
  56
  57     playlist_item_t *p_item =
  58         playlist_ItemGetByInput( p_playlist, p_input );
  59
  60     assert( p_item != NULL );
  61     playlist_item_t *p_parent = p_item->p_parent;
  62     assert( p_parent != NULL );
  63
  64     bool b_current = get_current_status_item( p_playlist ) == p_item;
  65     bool b_autostart = var_CreateGetBool( p_playlist, "playlist-autostart" );
  66     bool b_stop = p_item->i_flags & PLAYLIST_SUBITEM_STOP_FLAG;
  67     p_item->i_flags &= ~PLAYLIST_SUBITEM_STOP_FLAG;
  68
  69     int pos = 0;
  70     for( int i = 0; i < p_parent->i_children; i++ )
  71     {
  72         if( p_parent->pp_children[i] == p_item )
  73         {
  74             pos = i;
  75             break;
  76         }
  77     }
  78
  79     bool b_flat = false;
  80     playlist_item_t *p_up = p_item;
  81     while( p_up->p_parent )
  82     {
  83         if( p_up->p_parent == p_playlist->p_playing )
  84         {
  85             if( !pl_priv(p_playlist)->b_tree ) b_flat = true;
  86             break;
  87         }
  88         p_up = p_up->p_parent;
  89     }
  90     if( b_flat )
  91     {
  92         playlist_DeleteItem( p_playlist, p_item, true );
  93         p_item = playlist_InsertInputItemTree( p_playlist, p_parent,
  94                                                p_new_root, pos, true );
  95     }
  96     else
  97         p_item = playlist_InsertInputItemTree( p_playlist, p_item,
  98                                                p_new_root, PLAYLIST_END, false );
  99
 100     if( !b_flat ) var_SetAddress( p_playlist, "leaf-to-parent", p_input );
 101
 102     if( b_current )
 103     {
 104         if( ( b_stop && !b_flat ) || !b_autostart )
 105         {
 106             PL_UNLOCK;
 107             playlist_Stop( p_playlist );
 108             return;
 109         }
 110         else
 111         {
 112             playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
 113                 pl_Locked, get_current_status_node( p_playlist ), p_item );
 114         }
 115     }
 116
 117     PL_UNLOCK;
 118 }
 119 /*****************************************************************************
 120  * An input item's meta or duration has changed (Event Callback)
 121  *****************************************************************************/
 122 static void input_item_changed( const vlc_event_t * p_event,
 123                                 void * user_data )
 124 {
 125     playlist_item_t *p_item = user_data;
 126     VLC_UNUSED( p_event );
 127     var_SetAddress( p_item->p_playlist, "item-change", p_item->p_input );
 128 }
 129
 130 /*****************************************************************************
 131  * Listen to vlc_InputItemAddSubItem event
 132  *****************************************************************************/
 133 static void install_input_item_observer( playlist_item_t * p_item )
 134 {
 135     vlc_event_manager_t * p_em = &p_item->p_input->event_manager;
 136     vlc_event_attach( p_em, vlc_InputItemSubItemTreeAdded,
 137                       input_item_add_subitem_tree, p_item );
 138     vlc_event_attach( p_em, vlc_InputItemDurationChanged,
 139                       input_item_changed, p_item );
 140     vlc_event_attach( p_em, vlc_InputItemMetaChanged,
 141                       input_item_changed, p_item );
 142     vlc_event_attach( p_em, vlc_InputItemNameChanged,
 143                       input_item_changed, p_item );
 144     vlc_event_attach( p_em, vlc_InputItemInfoChanged,
 145                       input_item_changed, p_item );
 146     vlc_event_attach( p_em, vlc_InputItemErrorWhenReadingChanged,
 147                       input_item_changed, p_item );
 148 }
 149
 150 static void uninstall_input_item_observer( playlist_item_t * p_item )
 151 {
 152     vlc_event_manager_t * p_em = &p_item->p_input->event_manager;
 153     vlc_event_detach( p_em, vlc_InputItemSubItemTreeAdded,
 154                       input_item_add_subitem_tree, p_item );
 155     vlc_event_detach( p_em, vlc_InputItemMetaChanged,
 156                       input_item_changed, p_item );
 157     vlc_event_detach( p_em, vlc_InputItemDurationChanged,
 158                       input_item_changed, p_item );
 159     vlc_event_detach( p_em, vlc_InputItemNameChanged,
 160                       input_item_changed, p_item );
 161     vlc_event_detach( p_em, vlc_InputItemInfoChanged,
 162                       input_item_changed, p_item );
 163     vlc_event_detach( p_em, vlc_InputItemErrorWhenReadingChanged,
 164                       input_item_changed, p_item );
 165 }
 166
 167 /*****************************************************************************
 168  * Playlist item creation
 169  *****************************************************************************/
 170 playlist_item_t *playlist_ItemNewFromInput( playlist_t *p_playlist,
 171                                               input_item_t *p_input )
 172 {
 173     playlist_item_t* p_item = malloc( sizeof( playlist_item_t ) );
 174     if( !p_item )
 175         return NULL;
 176
 177     assert( p_input );
 178
 179     p_item->p_input = p_input;
 180     vlc_gc_incref( p_item->p_input );
 181
 182     p_item->i_id = ++pl_priv(p_playlist)->i_last_playlist_id;
 183
 184     p_item->p_parent = NULL;
 185     p_item->i_children = -1;
 186     p_item->pp_children = NULL;
 187     p_item->i_flags = 0;
 188     p_item->p_playlist = p_playlist;
 189
 190     install_input_item_observer( p_item );
 191
 192     return p_item;
 193 }
 194
 195 /***************************************************************************
 196  * Playlist item destruction
 197  ***************************************************************************/
 198
 199 /**
 200  * Release an item
 201  *
 202  * \param p_item item to delete
 203  * \return VLC_SUCCESS
 204 */
 205 int playlist_ItemRelease( playlist_item_t *p_item )
 206 {
 207     /* For the assert */
 208     playlist_t *p_playlist = p_item->p_playlist;
 209     PL_ASSERT_LOCKED;
 210
 211     /* Surprise, we can't actually do more because we
 212      * don't do refcounting, or eauivalent.
 213      * Because item are not only accessed by their id
 214      * using playlist_item outside the PL_LOCK isn't safe.
 215      * Most of the modules does that.
 216      *
 217      * Who wants to add proper memory management? */
 218     uninstall_input_item_observer( p_item );
 219     ARRAY_APPEND( pl_priv(p_playlist)->items_to_delete, p_item);
 220     return VLC_SUCCESS;
 221 }
 222
 223 /**
 224  * Delete input item
 225  *
 226  * Remove an input item when it appears from a root playlist item
 227  * \param p_playlist playlist object
 228  * \param p_input the input to delete
 229  * \param p_root root playlist item
 230  * \param b_do_stop must stop or not the playlist
 231  * \return VLC_SUCCESS or VLC_EGENERIC
 232 */
 233 static int DeleteFromInput( playlist_t *p_playlist, input_item_t *p_input,
 234                             playlist_item_t *p_root, bool b_do_stop )
 235 {
 236     PL_ASSERT_LOCKED;
 237     playlist_item_t *p_item = playlist_ItemFindFromInputAndRoot(
 238         p_playlist, p_input, p_root, false );
 239     if( !p_item ) return VLC_EGENERIC;
 240     return playlist_DeleteItem( p_playlist, p_item, b_do_stop );
 241 }
 242
 243 /**
 244  * Delete input item
 245  *
 246  * Remove an input item when it appears from a root playlist item
 247  * \param p_playlist playlist object
 248  * \param p_input the input to delete
 249  * \param p_root root playlist item
 250  * \param b_locked TRUE if the playlist is locked
 251  * \return VLC_SUCCESS or VLC_EGENERIC
 252  */
 253 int playlist_DeleteFromInputInParent( playlist_t *p_playlist,
 254                                       input_item_t *p_item,
 255                                       playlist_item_t *p_root, bool b_locked )
 256 {
 257     int i_ret;
 258     PL_LOCK_IF( !b_locked );
 259     i_ret = DeleteFromInput( p_playlist, p_item, p_root, true );
 260     PL_UNLOCK_IF( !b_locked );
 261     return i_ret;
 262 }
 263
 264 /**
 265  * Delete from input
 266  *
 267  * Search anywhere in playlist for an an input item and delete it
 268  * \param p_playlist playlist object
 269  * \param p_input the input to delete
 270  * \param b_locked TRUE if the playlist is locked
 271  * \return VLC_SUCCESS or VLC_ENOITEM
 272  */
 273 int playlist_DeleteFromInput( playlist_t *p_playlist, input_item_t *p_input,
 274                               bool b_locked )
 275 {
 276     int i_ret;
 277     PL_LOCK_IF( !b_locked );
 278     i_ret = DeleteFromInput( p_playlist, p_input,
 279                              p_playlist->p_root, true );
 280     PL_UNLOCK_IF( !b_locked );
 281     return ( i_ret == VLC_SUCCESS ? VLC_SUCCESS : VLC_ENOITEM );
 282 }
 283
 284 /**
 285  * Clear the playlist
 286  *
 287  * \param p_playlist playlist object
 288  * \param b_locked TRUE if the playlist is locked
 289  * \return nothing
 290  */
 291 void playlist_Clear( playlist_t * p_playlist, bool b_locked )
 292 {
 293     PL_LOCK_IF( !b_locked );
 294     playlist_NodeEmpty( p_playlist, p_playlist->p_playing, true );
 295     PL_UNLOCK_IF( !b_locked );
 296 }
 297
 298 /**
 299  * Delete playlist item
 300  *
 301  * Remove a playlist item from the playlist, given its id
 302  * This function is to be used only by the playlist
 303  * \param p_playlist playlist object
 304  * \param i_id id of the item do delete
 305  * \return VLC_SUCCESS or an error
 306  */
 307 int playlist_DeleteFromItemId( playlist_t *p_playlist, int i_id )
 308 {
 309     PL_ASSERT_LOCKED;
 310     playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_id );
 311     if( !p_item ) return VLC_EGENERIC;
 312     return playlist_DeleteItem( p_playlist, p_item, true );
 313 }
 314
 315 /***************************************************************************
 316  * Playlist item addition
 317  ***************************************************************************/
 318 /**
 319  * Playlist add
 320  *
 321  * Add an item to the playlist or the media library
 322  * \param p_playlist the playlist to add into
 323  * \param psz_uri the mrl to add to the playlist
 324  * \param psz_name a text giving a name or description of this item
 325  * \param i_mode the mode used when adding
 326  * \param i_pos the position in the playlist where to add. If this is
 327  *        PLAYLIST_END the item will be added at the end of the playlist
 328  *        regardless of its size
 329  * \param b_playlist TRUE for playlist, FALSE for media library
 330  * \param b_locked TRUE if the playlist is locked
 331  * \return VLC_SUCCESS or a VLC error code
 332  */
 333 int playlist_Add( playlist_t *p_playlist, const char *psz_uri,
 334                   const char *psz_name, int i_mode, int i_pos,
 335                   bool b_playlist, bool b_locked )
 336 {
 337     return playlist_AddExt( p_playlist, psz_uri, psz_name,
 338                             i_mode, i_pos, -1, 0, NULL, 0, b_playlist, b_locked );
 339 }
 340
 341 /**
 342  * Add a MRL into the playlist or the media library, duration and options given
 343  *
 344  * \param p_playlist the playlist to add into
 345  * \param psz_uri the mrl to add to the playlist
 346  * \param psz_name a text giving a name or description of this item
 347  * \param i_mode the mode used when adding
 348  * \param i_pos the position in the playlist where to add. If this is
 349  *        PLAYLIST_END the item will be added at the end of the playlist
 350  *        regardless of its size
 351  * \param i_duration length of the item in milliseconds.
 352  * \param i_options the number of options
 353  * \param ppsz_options an array of options
 354  * \param i_option_flags options flags
 355  * \param b_playlist TRUE for playlist, FALSE for media library
 356  * \param b_locked TRUE if the playlist is locked
 357  * \return VLC_SUCCESS or a VLC error code
 358 */
 359 int playlist_AddExt( playlist_t *p_playlist, const char * psz_uri,
 360                      const char *psz_name, int i_mode, int i_pos,
 361                      mtime_t i_duration,
 362                      int i_options, const char *const *ppsz_options,
 363                      unsigned i_option_flags,
 364                      bool b_playlist, bool b_locked )
 365 {
 366     int i_ret;
 367     input_item_t *p_input;
 368
 369     p_input = input_item_NewExt( p_playlist, psz_uri, psz_name,
 370                                  i_options, ppsz_options, i_option_flags,
 371                                  i_duration );
 372     if( p_input == NULL )
 373         return VLC_ENOMEM;
 374     i_ret = playlist_AddInput( p_playlist, p_input, i_mode, i_pos, b_playlist,
 375                                b_locked );
 376     vlc_gc_decref( p_input );
 377     return i_ret;
 378 }
 379
 380 /**
 381  * Add an input item to the playlist node
 382  *
 383  * \param p_playlist the playlist to add into
 384  * \param p_input the input item to add
 385  * \param i_mode the mode used when adding
 386  * \param i_pos the position in the playlist where to add. If this is
 387  *        PLAYLIST_END the item will be added at the end of the playlist
 388  *        regardless of its size
 389  * \param b_playlist TRUE for playlist, FALSE for media library
 390  * \param b_locked TRUE if the playlist is locked
 391  * \return VLC_SUCCESS or VLC_ENOMEM or VLC_EGENERIC
 392 */
 393 int playlist_AddInput( playlist_t* p_playlist, input_item_t *p_input,
 394                        int i_mode, int i_pos, bool b_playlist,
 395                        bool b_locked )
 396 {
 397     playlist_item_t *p_item;
 398     if( p_playlist->b_die ) return VLC_EGENERIC;
 399     if( !pl_priv(p_playlist)->b_doing_ml )
 400         PL_DEBUG( "adding item `%s' ( %s )", p_input->psz_name,
 401                                              p_input->psz_uri );
 402
 403     PL_LOCK_IF( !b_locked );
 404
 405     p_item = playlist_ItemNewFromInput( p_playlist, p_input );
 406     if( p_item == NULL ) return VLC_ENOMEM;
 407     AddItem( p_playlist, p_item,
 408              b_playlist ? p_playlist->p_playing :
 409                           p_playlist->p_media_library , i_mode, i_pos );
 410
 411     GoAndPreparse( p_playlist, i_mode, p_item );
 412
 413     PL_UNLOCK_IF( !b_locked );
 414     return VLC_SUCCESS;
 415 }
 416
 417 /**
 418  * Add an input item to a given node
 419  *
 420  * \param p_playlist the playlist to add into
 421  * \param p_input the input item to add
 422  * \param p_parent the parent item to add into
 423  * \param i_mode the mode used when addin
 424  * \param i_pos the position in the playlist where to add. If this is
 425  *        PLAYLIST_END the item will be added at the end of the playlist
 426  *        regardless of its size
 427  * \param b_locked TRUE if the playlist is locked
 428  * \return the new playlist item
 429  */
 430 playlist_item_t * playlist_NodeAddInput( playlist_t *p_playlist,
 431                                          input_item_t *p_input,
 432                                          playlist_item_t *p_parent,
 433                                          int i_mode, int i_pos,
 434                                          bool b_locked )
 435 {
 436     playlist_item_t *p_item;
 437     assert( p_input );
 438     assert( p_parent && p_parent->i_children != -1 );
 439
 440     if( p_playlist->b_die )
 441         return NULL;
 442     PL_LOCK_IF( !b_locked );
 443
 444     p_item = playlist_ItemNewFromInput( p_playlist, p_input );
 445     if( p_item == NULL ) return NULL;
 446     AddItem( p_playlist, p_item, p_parent, i_mode, i_pos );
 447
 448     GoAndPreparse( p_playlist, i_mode, p_item );
 449
 450     PL_UNLOCK_IF( !b_locked );
 451
 452     return p_item;
 453 }
 454
 455 /**
 456  * Insert a tree of input items into a given playlist node
 457  *
 458  * \param p_playlist the playlist to insert into
 459  * \param p_parent the receiving playlist node (can be an item)
 460  * \param p_node the root of input item tree,
 461           only it's contents will be inserted
 462  * \param i_pos the position in the playlist where to insert. If this is
 463  *        PLAYLIST_END the items will be added at the end of the playlist
 464  *        regardless of its size
 465  * \param b_flat TRUE if the new tree contents should be flattened into a list
 466  * \return the first new leaf inserted (in playing order)
 467  */
 468 playlist_item_t *playlist_InsertInputItemTree (
 469     playlist_t *p_playlist, playlist_item_t *p_parent,
 470     input_item_node_t *p_node, int i_pos, bool b_flat )
 471 {
 472   playlist_item_t *p_first_leaf = NULL;
 473   RecursiveAddIntoParent ( p_playlist, p_parent, p_node, i_pos, b_flat, &p_first_leaf );
 474   return p_first_leaf;
 475 }
 476
 477 /*****************************************************************************
 478  * Playlist item misc operations
 479  *****************************************************************************/
 480
 481 /**
 482  * Find an item within a root, given its input id.
 483  *
 484  * \param p_playlist the playlist object
 485  * \param p_item the input item
 486  * \param p_root root playlist item
 487  * \param b_items_only TRUE if we want the item himself
 488  * \return the first found item, or NULL if not found
 489  */
 490 playlist_item_t *playlist_ItemFindFromInputAndRoot( playlist_t *p_playlist,
 491                                                     input_item_t *p_item,
 492                                                     playlist_item_t *p_root,
 493                                                     bool b_items_only )
 494 {
 495     int i;
 496     for( i = 0 ; i< p_root->i_children ; i++ )
 497     {
 498         if( ( b_items_only ? p_root->pp_children[i]->i_children == -1 : 1 ) &&
 499             p_root->pp_children[i]->p_input == p_item )
 500         {
 501             return p_root->pp_children[i];
 502         }
 503         else if( p_root->pp_children[i]->i_children >= 0 )
 504         {
 505             playlist_item_t *p_search =
 506                  playlist_ItemFindFromInputAndRoot( p_playlist, p_item,
 507                                                     p_root->pp_children[i],
 508                                                     b_items_only );
 509             if( p_search ) return p_search;
 510         }
 511     }
 512     return NULL;
 513 }
 514
 515
 516 static int ItemIndex ( playlist_item_t *p_item )
 517 {
 518     for( int i = 0; i < p_item->p_parent->i_children; i++ )
 519         if( p_item->p_parent->pp_children[i] == p_item ) return i;
 520     return -1;
 521 }
 522
 523 /**
 524  * Moves an item
 525  *
 526  * This function must be entered with the playlist lock
 527  *
 528  * \param p_playlist the playlist
 529  * \param p_item the item to move
 530  * \param p_node the new parent of the item
 531  * \param i_newpos the new position under this new parent
 532  * \return VLC_SUCCESS or an error
 533  */
 534 int playlist_TreeMove( playlist_t * p_playlist, playlist_item_t *p_item,
 535                        playlist_item_t *p_node, int i_newpos )
 536 {
 537     PL_ASSERT_LOCKED;
 538
 539     if( p_node->i_children == -1 ) return VLC_EGENERIC;
 540
 541     playlist_item_t *p_detach = p_item->p_parent;
 542     int i_index = ItemIndex( p_item );
 543
 544     REMOVE_ELEM( p_detach->pp_children, p_detach->i_children, i_index );
 545
 546     if( p_detach == p_node && i_index < i_newpos )
 547         i_newpos--;
 548
 549     INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
 550     p_item->p_parent = p_node;
 551
 552     pl_priv( p_playlist )->b_reset_currently_playing = true;
 553     vlc_cond_signal( &pl_priv( p_playlist )->signal );
 554     return VLC_SUCCESS;
 555 }
 556
 557 /**
 558  * Moves an array of items
 559  *
 560  * This function must be entered with the playlist lock
 561  *
 562  * \param p_playlist the playlist
 563  * \param i_items the number of indexes to move
 564  * \param pp_items the array of indexes to move
 565  * \param p_node the target node
 566  * \param i_newpos the target position under this node
 567  * \return VLC_SUCCESS or an error
 568  */
 569 int playlist_TreeMoveMany( playlist_t *p_playlist,
 570                             int i_items, playlist_item_t **pp_items,
 571                             playlist_item_t *p_node, int i_newpos )
 572 {
 573     PL_ASSERT_LOCKED;
 574
 575     if ( p_node->i_children == -1 ) return VLC_EGENERIC;
 576
 577     int i;
 578     for( i = 0; i < i_items; i++ )
 579     {
 580         playlist_item_t *p_item = pp_items[i];
 581         int i_index = ItemIndex( p_item );
 582         playlist_item_t *p_parent = p_item->p_parent;
 583         REMOVE_ELEM( p_parent->pp_children, p_parent->i_children, i_index );
 584         if ( p_parent == p_node && i_index < i_newpos ) i_newpos--;
 585     }
 586     for( i = i_items - 1; i >= 0; i-- )
 587     {
 588         playlist_item_t *p_item = pp_items[i];
 589         INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
 590         p_item->p_parent = p_node;
 591     }
 592
 593     pl_priv( p_playlist )->b_reset_currently_playing = true;
 594     vlc_cond_signal( &pl_priv( p_playlist )->signal );
 595     return VLC_SUCCESS;
 596 }
 597
 598 /**
 599  * Send a notification that an item has been added to a node
 600  *
 601  * \param p_playlist the playlist object
 602  * \param i_item_id id of the item added
 603  * \param i_node_id id of the node in wich the item was added
 604  * \param b_signal TRUE if the function must send a signal
 605  * \return nothing
 606  */
 607 void playlist_SendAddNotify( playlist_t *p_playlist, int i_item_id,
 608                              int i_node_id, bool b_signal )
 609 {
 610     playlist_private_t *p_sys = pl_priv(p_playlist);
 611     PL_ASSERT_LOCKED;
 612
 613     p_sys->b_reset_currently_playing = true;
 614     if( b_signal )
 615         vlc_cond_signal( &p_sys->signal );
 616
 617     playlist_add_t add;
 618     add.i_item = i_item_id;
 619     add.i_node = i_node_id;
 620
 621     vlc_value_t val;
 622     val.p_address = &add;
 623
 624     var_Set( p_playlist, "playlist-item-append", val );
 625 }
 626
 627 /***************************************************************************
 628  * The following functions are local
 629  ***************************************************************************/
 630
 631 /* Enqueue an item for preparsing, and play it, if needed */
 632 static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
 633                            playlist_item_t *p_item )
 634 {
 635     PL_ASSERT_LOCKED;
 636     if( (i_mode & PLAYLIST_GO ) )
 637     {
 638         pl_priv(p_playlist)->request.b_request = true;
 639         pl_priv(p_playlist)->request.i_skip = 0;
 640         pl_priv(p_playlist)->request.p_item = p_item;
 641         if( pl_priv(p_playlist)->p_input )
 642             input_Stop( pl_priv(p_playlist)->p_input, true );
 643         pl_priv(p_playlist)->request.i_status = PLAYLIST_RUNNING;
 644         vlc_cond_signal( &pl_priv(p_playlist)->signal );
 645     }
 646     /* Preparse if no artist/album info, and hasn't been preparsed allready
 647        and if user has some preparsing option (auto-preparse variable)
 648        enabled*/
 649     char *psz_artist = input_item_GetArtist( p_item->p_input );
 650     char *psz_album = input_item_GetAlbum( p_item->p_input );
 651     if( pl_priv(p_playlist)->b_auto_preparse &&
 652         input_item_IsPreparsed( p_item->p_input ) == false &&
 653             ( EMPTY_STR( psz_artist ) || ( EMPTY_STR( psz_album ) ) )
 654           )
 655         playlist_PreparseEnqueue( p_playlist, p_item->p_input );
 656     free( psz_artist );
 657     free( psz_album );
 658 }
 659
 660 /* Add the playlist item to the requested node and fire a notification */
 661 static void AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
 662                      playlist_item_t *p_node, int i_mode, int i_pos )
 663 {
 664     PL_ASSERT_LOCKED;
 665     ARRAY_APPEND(p_playlist->items, p_item);
 666     ARRAY_APPEND(p_playlist->all_items, p_item);
 667
 668     if( i_pos == PLAYLIST_END )
 669         playlist_NodeAppend( p_playlist, p_item, p_node );
 670     else
 671         playlist_NodeInsert( p_playlist, p_item, p_node, i_pos );
 672
 673     if( !pl_priv(p_playlist)->b_doing_ml )
 674         playlist_SendAddNotify( p_playlist, p_item->i_id, p_node->i_id,
 675                                  !( i_mode & PLAYLIST_NO_REBUILD ) );
 676 }
 677
 678 /* Actually convert an item to a node */
 679 static void ChangeToNode( playlist_t *p_playlist, playlist_item_t *p_item )
 680 {
 681     int i;
 682     if( p_item->i_children != -1 ) return;
 683
 684     p_item->i_children = 0;
 685
 686     input_item_t *p_input = p_item->p_input;
 687     vlc_mutex_lock( &p_input->lock );
 688     p_input->i_type = ITEM_TYPE_NODE;
 689     vlc_mutex_unlock( &p_input->lock );
 690
 691     var_SetAddress( p_playlist, "item-change", p_item->p_input );
 692
 693     /* Remove it from the array of available items */
 694     ARRAY_BSEARCH( p_playlist->items,->i_id, int, p_item->i_id, i );
 695     if( i != -1 )
 696         ARRAY_REMOVE( p_playlist->items, i );
 697 }
 698
 699 /* Do the actual removal */
 700 int playlist_DeleteItem( playlist_t * p_playlist, playlist_item_t *p_item,
 701                         bool b_stop )
 702 {
 703     int i;
 704     int i_id = p_item->i_id;
 705     PL_ASSERT_LOCKED;
 706
 707     if( p_item->i_children > -1 )
 708     {
 709         return playlist_NodeDelete( p_playlist, p_item, true, false );
 710     }
 711
 712     pl_priv(p_playlist)->b_reset_currently_playing = true;
 713     var_SetInteger( p_playlist, "playlist-item-deleted", i_id );
 714
 715     /* Remove the item from the bank */
 716     ARRAY_BSEARCH( p_playlist->all_items,->i_id, int, i_id, i );
 717     if( i != -1 )
 718         ARRAY_REMOVE( p_playlist->all_items, i );
 719
 720     ARRAY_BSEARCH( p_playlist->items,->i_id, int, i_id, i );
 721     if( i != -1 )
 722         ARRAY_REMOVE( p_playlist->items, i );
 723
 724     /* Check if it is the current item */
 725     if( get_current_status_item( p_playlist ) == p_item )
 726     {
 727         /* Stop it if we have to */
 728         if( b_stop )
 729         {
 730             playlist_Control( p_playlist, PLAYLIST_STOP, pl_Locked );
 731             msg_Info( p_playlist, "stopping playback" );
 732         }
 733         /* In any case, this item can't be the next one to be played ! */
 734         set_current_status_item( p_playlist, NULL );
 735     }
 736
 737     ARRAY_BSEARCH( p_playlist->current,->i_id, int, i_id, i );
 738     if( i != -1 )
 739         ARRAY_REMOVE( p_playlist->current, i );
 740
 741     PL_DEBUG( "deleting item `%s'", p_item->p_input->psz_name );
 742
 743     /* Remove the item from its parent */
 744     playlist_NodeRemoveItem( p_playlist, p_item, p_item->p_parent );
 745
 746     playlist_ItemRelease( p_item );
 747
 748     return VLC_SUCCESS;
 749 }
 750
 751 static int RecursiveAddIntoParent (
 752     playlist_t *p_playlist, playlist_item_t *p_parent,
 753     input_item_node_t *p_node, int i_pos, bool b_flat,
 754     playlist_item_t **pp_first_leaf )
 755 {
 756   if( p_parent->i_children == -1 ) ChangeToNode( p_playlist, p_parent );
 757
 758   if( i_pos == PLAYLIST_END ) i_pos = p_parent->i_children;
 759
 760   for( int i = 0; i < p_node->i_children; i++ )
 761   {
 762       playlist_item_t *p_child = NULL;
 763       if( b_flat ? p_node->pp_children[i]->i_children == 0 : 1 )
 764       {
 765           p_child = playlist_NodeAddInput( p_playlist,
 766                                  p_node->pp_children[i]->p_item,
 767                                  p_parent,
 768                                  PLAYLIST_INSERT, i_pos,
 769                                  pl_Locked );
 770           i_pos++;
 771       }
 772       if( p_node->pp_children[i]->i_children > 0 )
 773       {
 774           if( b_flat )
 775           {
 776               i_pos = RecursiveAddIntoParent(
 777                                       p_playlist, p_parent,
 778                                       p_node->pp_children[i], i_pos, true,
 779                                       &p_child );
 780           }
 781           else
 782           {
 783               RecursiveAddIntoParent( p_playlist, p_child,
 784                                       p_node->pp_children[i], 0, false,
 785                                       &p_child );
 786           }
 787       }
 788       assert( p_child != NULL );
 789       if( i == 0 ) *pp_first_leaf = p_child;
 790   }
 791   return i_pos;
 792 }