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 playlist_item_t *ItemToNode( playlist_t *, playlist_item_t *, bool );
  40
  41 static int RecursiveAddIntoParent (
  42                 playlist_t *p_playlist, playlist_item_t *p_parent,
  43                 input_item_node_t *p_node, int i_pos, bool b_flat,
  44                 playlist_item_t **pp_first_leaf );
  45
  46 /*****************************************************************************
  47  * An input item has gained subitems (Event Callback)
  48  *****************************************************************************/
  49
  50 static void input_item_add_subitem_tree ( const vlc_event_t * p_event,
  51                                           void * user_data )
  52 {
  53     input_item_t *p_input = p_event->p_obj;
  54     playlist_t *p_playlist = (( playlist_item_t* ) user_data)->p_playlist;
  55     input_item_node_t *p_new_root = p_event->u.input_item_subitem_tree_added.p_root;
  56
  57     PL_LOCK;
  58
  59     playlist_item_t *p_item =
  60         playlist_ItemGetByInput( p_playlist, p_input );
  61
  62     assert( p_item != NULL );
  63     playlist_item_t *p_parent = p_item->p_parent;
  64     assert( p_parent != NULL );
  65
  66     bool b_play = var_CreateGetBool( p_playlist, "playlist-autostart" ) &&
  67                   get_current_status_item( p_playlist ) == p_item;
  68     bool b_stop = b_play && p_item->i_flags & PLAYLIST_SUBITEM_STOP_FLAG;
  69     p_item->i_flags &= ~PLAYLIST_SUBITEM_STOP_FLAG;
  70
  71     int pos = 0;
  72     for( int i = 0; i < p_parent->i_children; i++ )
  73     {
  74         if( p_parent->pp_children[i] == p_item )
  75         {
  76             pos = i;
  77             break;
  78         }
  79     }
  80
  81     bool b_flat = false;
  82     playlist_item_t *p_up = p_item;
  83     while( p_up->p_parent )
  84     {
  85         if( p_up->p_parent == p_playlist->p_playing ||
  86             p_up->p_parent == p_playlist->p_media_library )
  87         {
  88             if( !pl_priv(p_playlist)->b_tree ) b_flat = true;
  89             break;
  90         }
  91         p_up = p_up->p_parent;
  92     }
  93     if( b_flat )
  94     {
  95         playlist_DeleteItem( p_playlist, p_item, true );
  96         p_item = playlist_InsertInputItemTree( p_playlist, p_parent,
  97                                                p_new_root, pos, true );
  98     }
  99     else
 100         p_item = playlist_InsertInputItemTree( p_playlist, p_item,
 101                                                p_new_root, 0, false );
 102
 103     if( !b_flat ) var_SetAddress( p_playlist, "leaf-to-parent", p_input );
 104
 105     if( b_stop && !b_flat )
 106     {
 107         PL_UNLOCK;
 108         playlist_Stop( p_playlist );
 109         return;
 110     }
 111     else if( b_play )
 112     {
 113         playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
 114                           pl_Locked, get_current_status_node( p_playlist ), p_item );
 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  * Item to node
 483  *
 484  * Transform an item to a node. Return the node in the category tree, or NULL
 485  * if not found there
 486  * This function must be entered without the playlist lock
 487  * \param p_playlist the playlist object
 488  * \param p_item the item to transform
 489  * \param b_locked TRUE if the playlist is locked
 490  * \return the item transform in a node
 491  */
 492 static playlist_item_t *ItemToNode( playlist_t *p_playlist,
 493                                     playlist_item_t *p_item,
 494                                     bool b_locked )
 495 {
 496     PL_LOCK_IF( !b_locked );
 497
 498     assert( p_item->p_parent );
 499
 500     bool b_flat = false;
 501     playlist_item_t *p_up = p_item;
 502     while( p_up->p_parent )
 503     {
 504         if( p_up->p_parent == p_playlist->p_playing ||
 505             p_up->p_parent == p_playlist->p_media_library )
 506         {
 507             if( !pl_priv(p_playlist)->b_tree ) b_flat = true;
 508             break;
 509         }
 510         p_up = p_up->p_parent;
 511     }
 512
 513     if( !b_flat )
 514     {
 515         ChangeToNode( p_playlist, p_item );
 516         if( p_up == p_playlist->p_root )
 517             var_SetAddress( p_playlist, "item-change", p_item->p_input );
 518         PL_UNLOCK_IF( !b_locked );
 519         return p_item;
 520     }
 521     else
 522     {
 523         playlist_item_t *p_status_item = get_current_status_item( p_playlist );
 524         playlist_item_t *p_status_node = get_current_status_node( p_playlist );
 525         if( p_item == p_status_item )
 526         {
 527             /* We're deleting the current playlist item. Update
 528               * the playlist object to point at the previous item
 529               * so the playlist won't be restarted */
 530             playlist_item_t *p_prev_status_item = NULL;
 531             int i = 0;
 532             while( i < p_status_node->i_children &&
 533                     p_status_node->pp_children[i] != p_status_item )
 534             {
 535                 p_prev_status_item = p_status_node->pp_children[i];
 536                 i++;
 537             }
 538             if( i == p_status_node->i_children )
 539                 p_prev_status_item = NULL;
 540             if( p_prev_status_item )
 541                 set_current_status_item( p_playlist, p_prev_status_item );
 542         }
 543
 544         DeleteFromInput( p_playlist, p_item->p_input,
 545                           p_playlist->p_root, false );
 546
 547         pl_priv(p_playlist)->b_reset_currently_playing = true;
 548         vlc_cond_signal( &pl_priv(p_playlist)->signal );
 549
 550         PL_UNLOCK_IF( !b_locked );
 551         return p_item->p_parent;
 552     }
 553 }
 554
 555 /**
 556  * Find an item within a root, given its input id.
 557  *
 558  * \param p_playlist the playlist object
 559  * \param p_item the input item
 560  * \param p_root root playlist item
 561  * \param b_items_only TRUE if we want the item himself
 562  * \return the first found item, or NULL if not found
 563  */
 564 playlist_item_t *playlist_ItemFindFromInputAndRoot( playlist_t *p_playlist,
 565                                                     input_item_t *p_item,
 566                                                     playlist_item_t *p_root,
 567                                                     bool b_items_only )
 568 {
 569     int i;
 570     for( i = 0 ; i< p_root->i_children ; i++ )
 571     {
 572         if( ( b_items_only ? p_root->pp_children[i]->i_children == -1 : 1 ) &&
 573             p_root->pp_children[i]->p_input == p_item )
 574         {
 575             return p_root->pp_children[i];
 576         }
 577         else if( p_root->pp_children[i]->i_children >= 0 )
 578         {
 579             playlist_item_t *p_search =
 580                  playlist_ItemFindFromInputAndRoot( p_playlist, p_item,
 581                                                     p_root->pp_children[i],
 582                                                     b_items_only );
 583             if( p_search ) return p_search;
 584         }
 585     }
 586     return NULL;
 587 }
 588
 589
 590 static int ItemIndex ( playlist_item_t *p_item )
 591 {
 592     for( int i = 0; i < p_item->p_parent->i_children; i++ )
 593         if( p_item->p_parent->pp_children[i] == p_item ) return i;
 594     return -1;
 595 }
 596
 597 /**
 598  * Moves an item
 599  *
 600  * This function must be entered with the playlist lock
 601  *
 602  * \param p_playlist the playlist
 603  * \param p_item the item to move
 604  * \param p_node the new parent of the item
 605  * \param i_newpos the new position under this new parent
 606  * \return VLC_SUCCESS or an error
 607  */
 608 int playlist_TreeMove( playlist_t * p_playlist, playlist_item_t *p_item,
 609                        playlist_item_t *p_node, int i_newpos )
 610 {
 611     PL_ASSERT_LOCKED;
 612
 613     if( p_node->i_children == -1 ) return VLC_EGENERIC;
 614
 615     playlist_item_t *p_detach = p_item->p_parent;
 616     int i_index = ItemIndex( p_item );
 617
 618     REMOVE_ELEM( p_detach->pp_children, p_detach->i_children, i_index );
 619
 620     if( p_detach == p_node && i_index < i_newpos )
 621         i_newpos--;
 622
 623     INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
 624     p_item->p_parent = p_node;
 625
 626     pl_priv( p_playlist )->b_reset_currently_playing = true;
 627     vlc_cond_signal( &pl_priv( p_playlist )->signal );
 628     return VLC_SUCCESS;
 629 }
 630
 631 /**
 632  * Moves an array of items
 633  *
 634  * This function must be entered with the playlist lock
 635  *
 636  * \param p_playlist the playlist
 637  * \param i_items the number of indexes to move
 638  * \param pp_items the array of indexes to move
 639  * \param p_node the target node
 640  * \param i_newpos the target position under this node
 641  * \return VLC_SUCCESS or an error
 642  */
 643 int playlist_TreeMoveMany( playlist_t *p_playlist,
 644                             int i_items, playlist_item_t **pp_items,
 645                             playlist_item_t *p_node, int i_newpos )
 646 {
 647     PL_ASSERT_LOCKED;
 648
 649     if ( p_node->i_children == -1 ) return VLC_EGENERIC;
 650
 651     int i;
 652     for( i = 0; i < i_items; i++ )
 653     {
 654         playlist_item_t *p_item = pp_items[i];
 655         int i_index = ItemIndex( p_item );
 656         playlist_item_t *p_parent = p_item->p_parent;
 657         REMOVE_ELEM( p_parent->pp_children, p_parent->i_children, i_index );
 658         if ( p_parent == p_node && i_index < i_newpos ) i_newpos--;
 659     }
 660     for( i = i_items - 1; i >= 0; i-- )
 661     {
 662         playlist_item_t *p_item = pp_items[i];
 663         INSERT_ELEM( p_node->pp_children, p_node->i_children, i_newpos, p_item );
 664         p_item->p_parent = p_node;
 665     }
 666
 667     pl_priv( p_playlist )->b_reset_currently_playing = true;
 668     vlc_cond_signal( &pl_priv( p_playlist )->signal );
 669     return VLC_SUCCESS;
 670 }
 671
 672 /**
 673  * Send a notification that an item has been added to a node
 674  *
 675  * \param p_playlist the playlist object
 676  * \param i_item_id id of the item added
 677  * \param i_node_id id of the node in wich the item was added
 678  * \param b_signal TRUE if the function must send a signal
 679  * \return nothing
 680  */
 681 void playlist_SendAddNotify( playlist_t *p_playlist, int i_item_id,
 682                              int i_node_id, bool b_signal )
 683 {
 684     playlist_private_t *p_sys = pl_priv(p_playlist);
 685     PL_ASSERT_LOCKED;
 686
 687     p_sys->b_reset_currently_playing = true;
 688     if( b_signal )
 689         vlc_cond_signal( &p_sys->signal );
 690
 691     playlist_add_t add;
 692     add.i_item = i_item_id;
 693     add.i_node = i_node_id;
 694
 695     vlc_value_t val;
 696     val.p_address = &add;
 697
 698     var_Set( p_playlist, "playlist-item-append", val );
 699 }
 700
 701 /***************************************************************************
 702  * The following functions are local
 703  ***************************************************************************/
 704
 705 /* Enqueue an item for preparsing, and play it, if needed */
 706 static void GoAndPreparse( playlist_t *p_playlist, int i_mode,
 707                            playlist_item_t *p_item )
 708 {
 709     PL_ASSERT_LOCKED;
 710     if( (i_mode & PLAYLIST_GO ) )
 711     {
 712         pl_priv(p_playlist)->request.b_request = true;
 713         pl_priv(p_playlist)->request.i_skip = 0;
 714         pl_priv(p_playlist)->request.p_item = p_item;
 715         if( pl_priv(p_playlist)->p_input )
 716             input_Stop( pl_priv(p_playlist)->p_input, true );
 717         pl_priv(p_playlist)->request.i_status = PLAYLIST_RUNNING;
 718         vlc_cond_signal( &pl_priv(p_playlist)->signal );
 719     }
 720     /* Preparse if no artist/album info, and hasn't been preparsed allready
 721        and if user has some preparsing option (auto-preparse variable)
 722        enabled*/
 723     char *psz_artist = input_item_GetArtist( p_item->p_input );
 724     char *psz_album = input_item_GetAlbum( p_item->p_input );
 725     if( pl_priv(p_playlist)->b_auto_preparse &&
 726         input_item_IsPreparsed( p_item->p_input ) == false &&
 727             ( EMPTY_STR( psz_artist ) || ( EMPTY_STR( psz_album ) ) )
 728           )
 729         playlist_PreparseEnqueue( p_playlist, p_item->p_input );
 730     free( psz_artist );
 731     free( psz_album );
 732 }
 733
 734 /* Add the playlist item to the requested node and fire a notification */
 735 static void AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
 736                      playlist_item_t *p_node, int i_mode, int i_pos )
 737 {
 738     PL_ASSERT_LOCKED;
 739     ARRAY_APPEND(p_playlist->items, p_item);
 740     ARRAY_APPEND(p_playlist->all_items, p_item);
 741
 742     if( i_pos == PLAYLIST_END )
 743         playlist_NodeAppend( p_playlist, p_item, p_node );
 744     else
 745         playlist_NodeInsert( p_playlist, p_item, p_node, i_pos );
 746
 747     if( !pl_priv(p_playlist)->b_doing_ml )
 748         playlist_SendAddNotify( p_playlist, p_item->i_id, p_node->i_id,
 749                                  !( i_mode & PLAYLIST_NO_REBUILD ) );
 750 }
 751
 752 /* Actually convert an item to a node */
 753 static void ChangeToNode( playlist_t *p_playlist, playlist_item_t *p_item )
 754 {
 755     int i;
 756     if( p_item->i_children == -1 )
 757         p_item->i_children = 0;
 758
 759     /* Remove it from the array of available items */
 760     ARRAY_BSEARCH( p_playlist->items,->i_id, int, p_item->i_id, i );
 761     if( i != -1 )
 762         ARRAY_REMOVE( p_playlist->items, i );
 763 }
 764
 765 /* Do the actual removal */
 766 int playlist_DeleteItem( playlist_t * p_playlist, playlist_item_t *p_item,
 767                         bool b_stop )
 768 {
 769     int i;
 770     int i_id = p_item->i_id;
 771     PL_ASSERT_LOCKED;
 772
 773     if( p_item->i_children > -1 )
 774     {
 775         return playlist_NodeDelete( p_playlist, p_item, true, false );
 776     }
 777
 778     pl_priv(p_playlist)->b_reset_currently_playing = true;
 779     var_SetInteger( p_playlist, "playlist-item-deleted", i_id );
 780
 781     /* Remove the item from the bank */
 782     ARRAY_BSEARCH( p_playlist->all_items,->i_id, int, i_id, i );
 783     if( i != -1 )
 784         ARRAY_REMOVE( p_playlist->all_items, i );
 785
 786     ARRAY_BSEARCH( p_playlist->items,->i_id, int, i_id, i );
 787     if( i != -1 )
 788         ARRAY_REMOVE( p_playlist->items, i );
 789
 790     /* Check if it is the current item */
 791     if( get_current_status_item( p_playlist ) == p_item )
 792     {
 793         /* Stop it if we have to */
 794         if( b_stop )
 795         {
 796             playlist_Control( p_playlist, PLAYLIST_STOP, pl_Locked );
 797             msg_Info( p_playlist, "stopping playback" );
 798         }
 799         /* In any case, this item can't be the next one to be played ! */
 800         set_current_status_item( p_playlist, NULL );
 801     }
 802
 803     ARRAY_BSEARCH( p_playlist->current,->i_id, int, i_id, i );
 804     if( i != -1 )
 805         ARRAY_REMOVE( p_playlist->current, i );
 806
 807     PL_DEBUG( "deleting item `%s'", p_item->p_input->psz_name );
 808
 809     /* Remove the item from its parent */
 810     playlist_NodeRemoveItem( p_playlist, p_item, p_item->p_parent );
 811
 812     playlist_ItemRelease( p_item );
 813
 814     return VLC_SUCCESS;
 815 }
 816
 817 static int RecursiveAddIntoParent (
 818     playlist_t *p_playlist, playlist_item_t *p_parent,
 819     input_item_node_t *p_node, int i_pos, bool b_flat,
 820     playlist_item_t **pp_first_leaf )
 821 {
 822   if( p_parent->i_children == -1 ) ChangeToNode( p_playlist, p_parent );
 823
 824   if( i_pos == PLAYLIST_END ) i_pos = p_parent->i_children;
 825
 826   for( int i = 0; i < p_node->i_children; i++ )
 827   {
 828       playlist_item_t *p_child = NULL;
 829       if( b_flat ? p_node->pp_children[i]->i_children == 0 : 1 )
 830       {
 831           p_child = playlist_NodeAddInput( p_playlist,
 832                                  p_node->pp_children[i]->p_item,
 833                                  p_parent,
 834                                  PLAYLIST_INSERT, i_pos,
 835                                  pl_Locked );
 836           i_pos++;
 837       }
 838       if( p_node->pp_children[i]->i_children > 0 )
 839       {
 840           if( b_flat )
 841           {
 842               i_pos = RecursiveAddIntoParent(
 843                                       p_playlist, p_parent,
 844                                       p_node->pp_children[i], i_pos, true,
 845                                       &p_child );
 846           }
 847           else
 848           {
 849               RecursiveAddIntoParent( p_playlist, p_child,
 850                                       p_node->pp_children[i], 0, false,
 851                                       &p_child );
 852           }
 853       }
 854       assert( p_child != NULL );
 855       if( i == 0 ) *pp_first_leaf = p_child;
 856   }
 857   return i_pos;
 858 }