git.sesse.net Git - vlc/blob - src/control/media_list_player.c

   1 /*****************************************************************************
   2  * media_list_player.c: libvlc new API media_list player functions
   3  *****************************************************************************
   4  * Copyright (C) 2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <vlc/libvlc.h>
  29 #include <vlc/libvlc_media.h>
  30 #include <vlc/libvlc_media_list.h>
  31 #include <vlc/libvlc_media_player.h>
  32 #include <vlc/libvlc_media_list_player.h>
  33 #include <vlc/libvlc_events.h>
  34 #include <assert.h>
  35
  36 #include "libvlc_internal.h"
  37
  38 #include "media_internal.h" // Abuse, could and should be removed
  39 #include "media_list_path.h"
  40
  41 //#define DEBUG_MEDIA_LIST_PLAYER
  42
  43 /* This is a very dummy implementation of playlist on top of
  44  * media_list and media_player.
  45  *
  46  * All this code is doing is simply computing the next item
  47  * of a tree of media_list (see get_next_index()), and play
  48  * the next item when the current is over. This is happening
  49  * via the event callback media_player_reached_end().
  50  *
  51  * This is thread safe, and we use a two keys (locks) scheme
  52  * to discriminate between callbacks and regular uses.
  53  */
  54
  55 struct libvlc_media_list_player_t
  56 {
  57     libvlc_event_manager_t *    p_event_manager;
  58     libvlc_instance_t *         p_libvlc_instance;
  59     int                         i_refcount;
  60     /* Protect access to this structure. */
  61     vlc_mutex_t                 object_lock;
  62     /* Protect access to this structure and from callback execution. */
  63     vlc_mutex_t                 mp_callback_lock;
  64     /* Indicate to media player callbacks that they are cancelled. */
  65     bool                        are_mp_callback_cancelled;
  66     libvlc_media_list_path_t    current_playing_item_path;
  67     libvlc_media_t *            p_current_playing_item;
  68     libvlc_media_list_t *       p_mlist;
  69     libvlc_media_player_t *     p_mi;
  70     libvlc_playback_mode_t      e_playback_mode;
  71 };
  72
  73 /* This is not yet exported by libvlccore */
  74 static inline void vlc_assert_locked(vlc_mutex_t *mutex)
  75 {
  76     VLC_UNUSED(mutex);
  77 }
  78
  79 /*
  80  * Forward declaration
  81  */
  82
  83 static void set_relative_playlist_position_and_play(
  84                                             libvlc_media_list_player_t * p_mlp,
  85                                             int i_relative_position,
  86                                             libvlc_exception_t * p_e);
  87 static void stop(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e);
  88
  89 /*
  90  * Private functions
  91  */
  92
  93 /**************************************************************************
  94  * Shortcuts
  95  **************************************************************************/
  96 static inline void lock(libvlc_media_list_player_t * p_mlp)
  97 {
  98     // Obtain an access to this structure
  99     vlc_mutex_lock(&p_mlp->object_lock);
 100
 101     // Make sure no callback will occurs at the same time
 102     vlc_mutex_lock(&p_mlp->mp_callback_lock);
 103 }
 104
 105 static inline void unlock(libvlc_media_list_player_t * p_mlp)
 106 {
 107     vlc_mutex_unlock(&p_mlp->mp_callback_lock);
 108     vlc_mutex_unlock(&p_mlp->object_lock);
 109 }
 110
 111 static inline void assert_locked(libvlc_media_list_player_t * p_mlp)
 112 {
 113     vlc_assert_locked(&p_mlp->mp_callback_lock);
 114 }
 115
 116 static inline libvlc_event_manager_t * mlist_em(libvlc_media_list_player_t * p_mlp)
 117 {
 118     assert_locked(p_mlp);
 119     return libvlc_media_list_event_manager(p_mlp->p_mlist, NULL);
 120 }
 121
 122 static inline libvlc_event_manager_t * mplayer_em(libvlc_media_list_player_t * p_mlp)
 123 {
 124     assert_locked(p_mlp);
 125     return libvlc_media_player_event_manager(p_mlp->p_mi, NULL);
 126 }
 127
 128 /**************************************************************************
 129  *       get_next_path (private)
 130  *
 131  *  Returns the path to the next item in the list.
 132  *  If looping is specified and the current item is the last list item in
 133  *  the list it will return the first item in the list.
 134  **************************************************************************/
 135 static libvlc_media_list_path_t
 136 get_next_path(libvlc_media_list_player_t * p_mlp, bool b_loop)
 137 {
 138     assert_locked(p_mlp);
 139
 140     /* We are entered with libvlc_media_list_lock(p_mlp->p_list) */
 141     libvlc_media_list_path_t ret;
 142     libvlc_media_list_t * p_parent_of_playing_item;
 143     libvlc_media_list_t * p_sublist_of_playing_item;
 144
 145     if (!p_mlp->current_playing_item_path)
 146     {
 147         if (!libvlc_media_list_count(p_mlp->p_mlist, NULL))
 148             return NULL;
 149         return libvlc_media_list_path_with_root_index(0);
 150     }
 151
 152     p_sublist_of_playing_item = libvlc_media_list_sublist_at_path(
 153                             p_mlp->p_mlist,
 154                             p_mlp->current_playing_item_path);
 155
 156     /* If item just gained a sublist just play it */
 157     if (p_sublist_of_playing_item)
 158     {
 159         libvlc_media_list_release(p_sublist_of_playing_item);
 160         return libvlc_media_list_path_copy_by_appending(p_mlp->current_playing_item_path, 0);
 161     }
 162
 163     /* Try to catch parent element */
 164     p_parent_of_playing_item = libvlc_media_list_parentlist_at_path(p_mlp->p_mlist,
 165                             p_mlp->current_playing_item_path);
 166
 167     int depth = libvlc_media_list_path_depth(p_mlp->current_playing_item_path);
 168     if (depth < 1 || !p_parent_of_playing_item)
 169         return NULL;
 170
 171     ret = libvlc_media_list_path_copy(p_mlp->current_playing_item_path);
 172     ret[depth - 1]++; /* set to next element */
 173
 174     /* If this goes beyond the end of the list */
 175     while(ret[depth-1] >= libvlc_media_list_count(p_parent_of_playing_item, NULL))
 176     {
 177         depth--;
 178         if (depth <= 0)
 179         {
 180             if(b_loop)
 181             {
 182                 ret[0] = 0;
 183                 ret[1] = -1;
 184                 break;
 185             }
 186             else
 187             {
 188                 free(ret);
 189                 libvlc_media_list_release(p_parent_of_playing_item);
 190                 return NULL;
 191             }
 192         }
 193         ret[depth] = -1;
 194         ret[depth-1]++;
 195         p_parent_of_playing_item  = libvlc_media_list_parentlist_at_path(
 196                                         p_mlp->p_mlist,
 197                                         ret);
 198     }
 199
 200     libvlc_media_list_release(p_parent_of_playing_item);
 201     return ret;
 202 }
 203
 204 /**************************************************************************
 205  *       find_last_item (private)
 206  *
 207  *  Returns the path of the last descendant of a given item path.
 208  *  Note: Due to the recursive nature of the function and the need to free
 209  *        media list paths, paths passed in may be freed if they are replaced.
 210           Recommended usage is to set return value to the same path that was
 211           passed to the function (i.e. item = find_last_item(list, item); )
 212  **************************************************************************/
 213 static libvlc_media_list_path_t
 214 find_last_item( libvlc_media_list_t * p_mlist, libvlc_media_list_path_t current_item )
 215 {
 216     libvlc_media_list_t * p_sublist = libvlc_media_list_sublist_at_path(p_mlist, current_item);
 217     libvlc_media_list_path_t last_item_path = current_item;
 218
 219     if(p_sublist)
 220     {
 221         int i_count = libvlc_media_list_count(p_sublist, NULL);
 222         if(i_count > 0)
 223         {
 224             /* Add the last sublist item to the path. */
 225             last_item_path = libvlc_media_list_path_copy_by_appending(current_item, i_count - 1);
 226             free(current_item);
 227             /* Check that sublist item for more descendants. */
 228             last_item_path = find_last_item(p_mlist, last_item_path);
 229         }
 230
 231         libvlc_media_list_release(p_sublist);
 232     }
 233
 234     return last_item_path;
 235 }
 236
 237 /**************************************************************************
 238  *       get_previous_path (private)
 239  *
 240  *  Returns the path to the preceding item in the list.
 241  *  If looping is specified and the current item is the first list item in
 242  *  the list it will return the last descendant of the last item in the list.
 243  **************************************************************************/
 244 static libvlc_media_list_path_t
 245 get_previous_path(libvlc_media_list_player_t * p_mlp, bool b_loop)
 246 {
 247     assert_locked(p_mlp);
 248
 249     /* We are entered with libvlc_media_list_lock(p_mlp->p_list) */
 250     libvlc_media_list_path_t ret;
 251     libvlc_media_list_t * p_parent_of_playing_item;
 252
 253     if (!p_mlp->current_playing_item_path)
 254     {
 255         if (!libvlc_media_list_count(p_mlp->p_mlist, NULL))
 256             return NULL;
 257         return libvlc_media_list_path_with_root_index(0);
 258     }
 259
 260     /* Try to catch parent element */
 261     p_parent_of_playing_item = libvlc_media_list_parentlist_at_path(
 262                                             p_mlp->p_mlist,
 263                                             p_mlp->current_playing_item_path);
 264
 265     int depth = libvlc_media_list_path_depth(p_mlp->current_playing_item_path);
 266     if (depth < 1 || !p_parent_of_playing_item)
 267         return NULL;
 268
 269     /* Set the return path to the current path */
 270     ret = libvlc_media_list_path_copy(p_mlp->current_playing_item_path);
 271
 272     /* Change the return path to the previous list entry */
 273     ret[depth - 1]--; /* set to previous element */
 274     ret[depth] = -1;
 275
 276     /* Is the return path is beyond the start of the current list? */
 277     if(ret[depth - 1] < 0)
 278     {
 279         /* Move to parent of current item */
 280         depth--;
 281
 282         /* Are we at the root level of the tree? */
 283         if (depth <= 0)
 284         {
 285             // Is looping enabled?
 286             if(b_loop)
 287             {
 288                 int i_count = libvlc_media_list_count(p_parent_of_playing_item, NULL);
 289
 290                 /* Set current play item to the last element in the list */
 291                 ret[0] = i_count - 1;
 292                 ret[1] = -1;
 293
 294                 /* Set the return path to the last descendant item of the current item */
 295                 ret = find_last_item(p_mlp->p_mlist, ret);
 296             }
 297             else
 298             {
 299                 /* No looping so return empty path. */
 300                 free(ret);
 301                 ret = NULL;
 302             }
 303         }
 304         else
 305         {
 306             /* This is the case of moving backward from the beginning of the
 307             *  subitem list to its parent item.
 308             *  This ensures that current path is properly terminated to
 309             *  use that parent.
 310             */
 311             ret[depth] = -1;
 312         }
 313     }
 314     else
 315     {
 316         ret = find_last_item(p_mlp->p_mlist, ret);
 317     }
 318
 319     libvlc_media_list_release(p_parent_of_playing_item);
 320     return ret;
 321 }
 322
 323 /**************************************************************************
 324  *       media_player_reached_end (private) (Event Callback)
 325  **************************************************************************/
 326 static void
 327 media_player_reached_end(const libvlc_event_t * p_event, void * p_user_data)
 328 {
 329     VLC_UNUSED(p_event);
 330     libvlc_media_list_player_t * p_mlp = p_user_data;
 331     libvlc_exception_t e;
 332     libvlc_exception_init(&e);
 333
 334     vlc_mutex_lock(&p_mlp->mp_callback_lock);
 335     if (!p_mlp->are_mp_callback_cancelled)
 336         set_relative_playlist_position_and_play(p_mlp, 1, &e);
 337     vlc_mutex_unlock(&p_mlp->mp_callback_lock);
 338
 339     // There is no point in reporting an error from this callback
 340     libvlc_exception_clear(&e);
 341 }
 342
 343 /**************************************************************************
 344  *       playlist_item_deleted (private) (Event Callback)
 345  **************************************************************************/
 346 static void
 347 mlist_item_deleted(const libvlc_event_t * p_event, void * p_user_data)
 348 {
 349     // Nothing to do. For now.
 350     (void)p_event; (void)p_user_data;
 351 }
 352
 353
 354 /**************************************************************************
 355  * install_playlist_observer (private)
 356  **************************************************************************/
 357 static void
 358 install_playlist_observer(libvlc_media_list_player_t * p_mlp)
 359 {
 360     assert_locked(p_mlp);
 361     libvlc_event_attach(mlist_em(p_mlp), libvlc_MediaListItemDeleted, mlist_item_deleted, p_mlp, NULL);
 362 }
 363
 364 /**************************************************************************
 365  * uninstall_playlist_observer (private)
 366  **************************************************************************/
 367 static void
 368 uninstall_playlist_observer(libvlc_media_list_player_t * p_mlp)
 369 {
 370     assert_locked(p_mlp);
 371     if (!p_mlp->p_mlist) return;
 372     libvlc_event_detach(mlist_em(p_mlp), libvlc_MediaListItemDeleted, mlist_item_deleted, p_mlp, NULL);
 373 }
 374
 375 /**************************************************************************
 376  * install_media_player_observer (private)
 377  **************************************************************************/
 378 static void
 379 install_media_player_observer(libvlc_media_list_player_t * p_mlp)
 380 {
 381     assert_locked(p_mlp);
 382     libvlc_event_attach_async(mplayer_em(p_mlp), libvlc_MediaPlayerEndReached, media_player_reached_end, p_mlp, NULL);
 383 }
 384
 385
 386 /**************************************************************************
 387  *       uninstall_media_player_observer (private)
 388  **************************************************************************/
 389 static void
 390 uninstall_media_player_observer(libvlc_media_list_player_t * p_mlp)
 391 {
 392     assert_locked(p_mlp);
 393     if (!p_mlp->p_mi) return;
 394
 395     // From now on, media_player callback won't be relevant.
 396     p_mlp->are_mp_callback_cancelled = true;
 397
 398     // Allow callbacks to run, because detach() will wait until all callbacks are processed.
 399     // This is safe because only callbacks are allowed, and there execution will be cancelled.
 400     vlc_mutex_unlock(&p_mlp->mp_callback_lock);
 401     libvlc_event_detach(mplayer_em(p_mlp), libvlc_MediaPlayerEndReached, media_player_reached_end, p_mlp, NULL);
 402
 403     // Now, lock back the callback lock. No more callback will be present from this point.
 404     vlc_mutex_lock(&p_mlp->mp_callback_lock);
 405     p_mlp->are_mp_callback_cancelled = false;
 406
 407     // What is here is safe, because we guarantee that we won't be able to anything concurrently,
 408     // - except (cancelled) callbacks - thanks to the object_lock.
 409 }
 410
 411 /**************************************************************************
 412  *       set_current_playing_item (private)
 413  *
 414  * Playlist lock should be held
 415  **************************************************************************/
 416 static void
 417 set_current_playing_item(libvlc_media_list_player_t * p_mlp, libvlc_media_list_path_t path)
 418 {
 419     assert_locked(p_mlp);
 420
 421     /* First, save the new path that we are going to play */
 422     if (p_mlp->current_playing_item_path != path)
 423     {
 424         free(p_mlp->current_playing_item_path);
 425         p_mlp->current_playing_item_path = path;
 426     }
 427
 428     if (!path)
 429         return;
 430
 431     libvlc_media_t * p_md;
 432     p_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, path);
 433     if (!p_md)
 434         return;
 435
 436     /* Make sure media_player_reached_end() won't get called */
 437     uninstall_media_player_observer(p_mlp);
 438
 439     /* Create a new media_player if there is none */
 440     if (!p_mlp->p_mi)
 441         p_mlp->p_mi = libvlc_media_player_new_from_media(p_md, NULL);
 442
 443     libvlc_media_player_set_media(p_mlp->p_mi, p_md, NULL);
 444
 445     install_media_player_observer(p_mlp);
 446     libvlc_media_release(p_md); /* for libvlc_media_list_item_at_index */
 447 }
 448
 449 /*
 450  * Public libvlc functions
 451  */
 452
 453 /**************************************************************************
 454  *         new (Public)
 455  **************************************************************************/
 456 libvlc_media_list_player_t *
 457 libvlc_media_list_player_new(libvlc_instance_t * p_instance, libvlc_exception_t * p_e)
 458 {
 459     (void)p_e;
 460     libvlc_media_list_player_t * p_mlp;
 461     p_mlp = calloc( 1, sizeof(libvlc_media_list_player_t) );
 462     if (!p_mlp)
 463         return NULL;
 464
 465     libvlc_retain(p_instance);
 466     p_mlp->p_libvlc_instance = p_instance;
 467     p_mlp->i_refcount = 1;
 468     vlc_mutex_init(&p_mlp->object_lock);
 469     vlc_mutex_init(&p_mlp->mp_callback_lock);
 470     p_mlp->p_event_manager = libvlc_event_manager_new(p_mlp, p_instance, p_e);
 471     libvlc_event_manager_register_event_type(p_mlp->p_event_manager, libvlc_MediaListPlayerNextItemSet, p_e);
 472     p_mlp->e_playback_mode = libvlc_playback_mode_default;
 473
 474     return p_mlp;
 475 }
 476
 477 /**************************************************************************
 478  *         release (Public)
 479  **************************************************************************/
 480 void libvlc_media_list_player_release(libvlc_media_list_player_t * p_mlp)
 481 {
 482     if (!p_mlp)
 483         return;
 484
 485     lock(p_mlp);
 486     p_mlp->i_refcount--;
 487     if (p_mlp->i_refcount > 0)
 488     {
 489         unlock(p_mlp);
 490         return;
 491     }
 492
 493     assert(p_mlp->i_refcount == 0);
 494
 495     /* Keep the lock(), because the uninstall functions
 496      * check for it. That's convenient. */
 497
 498     if (p_mlp->p_mi)
 499     {
 500         uninstall_media_player_observer(p_mlp);
 501         libvlc_media_player_release(p_mlp->p_mi);
 502     }
 503     if (p_mlp->p_mlist)
 504     {
 505         uninstall_playlist_observer(p_mlp);
 506         libvlc_media_list_release(p_mlp->p_mlist);
 507     }
 508
 509     unlock(p_mlp);
 510     vlc_mutex_destroy(&p_mlp->object_lock);
 511     vlc_mutex_destroy(&p_mlp->mp_callback_lock);
 512
 513     libvlc_event_manager_release(p_mlp->p_event_manager);
 514
 515     free(p_mlp->current_playing_item_path);
 516     libvlc_release(p_mlp->p_libvlc_instance);
 517     free(p_mlp);
 518 }
 519
 520 /**************************************************************************
 521  *        event_manager (Public)
 522  **************************************************************************/
 523 libvlc_event_manager_t *
 524 libvlc_media_list_player_event_manager(libvlc_media_list_player_t * p_mlp)
 525 {
 526     return p_mlp->p_event_manager;
 527 }
 528
 529 /**************************************************************************
 530  *        set_media_player (Public)
 531  **************************************************************************/
 532 void libvlc_media_list_player_set_media_player(libvlc_media_list_player_t * p_mlp, libvlc_media_player_t * p_mi, libvlc_exception_t * p_e)
 533 {
 534     VLC_UNUSED(p_e);
 535
 536     lock(p_mlp);
 537
 538     if (p_mlp->p_mi)
 539     {
 540         uninstall_media_player_observer(p_mlp);
 541         libvlc_media_player_release(p_mlp->p_mi);
 542     }
 543     libvlc_media_player_retain(p_mi);
 544     p_mlp->p_mi = p_mi;
 545
 546     install_media_player_observer(p_mlp);
 547
 548     unlock(p_mlp);
 549 }
 550
 551 /**************************************************************************
 552  *       set_media_list (Public)
 553  **************************************************************************/
 554 void libvlc_media_list_player_set_media_list(libvlc_media_list_player_t * p_mlp, libvlc_media_list_t * p_mlist, libvlc_exception_t * p_e)
 555 {
 556     VLC_UNUSED( p_e );
 557     assert (p_mlist);
 558
 559     lock(p_mlp);
 560     if (p_mlp->p_mlist)
 561     {
 562         uninstall_playlist_observer(p_mlp);
 563         libvlc_media_list_release(p_mlp->p_mlist);
 564     }
 565     libvlc_media_list_retain(p_mlist);
 566     p_mlp->p_mlist = p_mlist;
 567
 568     install_playlist_observer(p_mlp);
 569
 570     unlock(p_mlp);
 571 }
 572
 573 /**************************************************************************
 574  *        Play (Public)
 575  **************************************************************************/
 576 void libvlc_media_list_player_play(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
 577 {
 578     lock(p_mlp);
 579     if (!p_mlp->current_playing_item_path)
 580     {
 581         set_relative_playlist_position_and_play(p_mlp, 1, p_e);
 582         unlock(p_mlp);
 583         return; /* Will set to play */
 584     }
 585     libvlc_media_player_play(p_mlp->p_mi, p_e);
 586     unlock(p_mlp);
 587 }
 588
 589
 590 /**************************************************************************
 591  *        Pause (Public)
 592  **************************************************************************/
 593 void libvlc_media_list_player_pause(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
 594 {
 595     lock(p_mlp);
 596     if (!p_mlp->p_mi)
 597     {
 598         unlock(p_mlp);
 599         return;
 600     }
 601     libvlc_media_player_pause(p_mlp->p_mi, p_e);
 602     unlock(p_mlp);
 603 }
 604
 605 /**************************************************************************
 606  *        is_playing (Public)
 607  **************************************************************************/
 608 int
 609 libvlc_media_list_player_is_playing(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
 610 {
 611     libvlc_state_t state = libvlc_media_player_get_state(p_mlp->p_mi, p_e);
 612     return (state == libvlc_Opening) || (state == libvlc_Buffering) ||
 613            (state == libvlc_Playing);
 614 }
 615
 616 /**************************************************************************
 617  *        State (Public)
 618  **************************************************************************/
 619 libvlc_state_t
 620 libvlc_media_list_player_get_state(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
 621 {
 622     if (!p_mlp->p_mi)
 623         return libvlc_Ended;
 624     return libvlc_media_player_get_state(p_mlp->p_mi, p_e);
 625 }
 626
 627 /**************************************************************************
 628  *        Play item at index (Public)
 629  **************************************************************************/
 630 void libvlc_media_list_player_play_item_at_index(libvlc_media_list_player_t * p_mlp, int i_index, libvlc_exception_t * p_e)
 631 {
 632     VLC_UNUSED(p_e);
 633
 634     lock(p_mlp);
 635     set_current_playing_item(p_mlp, libvlc_media_list_path_with_root_index(i_index));
 636     libvlc_media_player_play(p_mlp->p_mi, p_e);
 637     unlock(p_mlp);
 638
 639     /* Send the next item event */
 640     libvlc_event_t event;
 641     event.type = libvlc_MediaListPlayerNextItemSet;
 642     libvlc_event_send(p_mlp->p_event_manager, &event);
 643 }
 644
 645 /**************************************************************************
 646  *        Play item (Public)
 647  **************************************************************************/
 648 void libvlc_media_list_player_play_item(libvlc_media_list_player_t * p_mlp, libvlc_media_t * p_md, libvlc_exception_t * p_e)
 649 {
 650     lock(p_mlp);
 651     libvlc_media_list_path_t path = libvlc_media_list_path_of_item(p_mlp->p_mlist, p_md);
 652     if (!path)
 653     {
 654         libvlc_exception_raise(p_e);
 655         libvlc_printerr("Item not found in media list");
 656         unlock(p_mlp);
 657         return;
 658     }
 659
 660     set_current_playing_item(p_mlp, path);
 661     libvlc_media_player_play(p_mlp->p_mi, p_e);
 662     unlock(p_mlp);
 663 }
 664
 665 /**************************************************************************
 666  *       Stop (Private)
 667  *
 668  * Lock must be held.
 669  **************************************************************************/
 670 static void stop(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
 671 {
 672     assert_locked(p_mlp);
 673
 674     if (p_mlp->p_mi)
 675     {
 676         /* We are not interested in getting media stop event now */
 677         uninstall_media_player_observer(p_mlp);
 678         libvlc_media_player_stop(p_mlp->p_mi, p_e);
 679         install_media_player_observer(p_mlp);
 680     }
 681
 682     free(p_mlp->current_playing_item_path);
 683     p_mlp->current_playing_item_path = NULL;
 684 }
 685
 686 /**************************************************************************
 687  *       Stop (Public)
 688  **************************************************************************/
 689 void libvlc_media_list_player_stop(libvlc_media_list_player_t * p_mlp,
 690                                    libvlc_exception_t * p_e)
 691 {
 692     lock(p_mlp);
 693     stop(p_mlp, p_e);
 694     unlock(p_mlp);
 695 }
 696
 697 /**************************************************************************
 698  *       Set relative playlist position and play (Private)
 699  *
 700  * Sets the currently played item to the given relative play item position
 701  * (based on the currently playing item) and then begins the new item playback.
 702  * Lock must be held.
 703  **************************************************************************/
 704 static void set_relative_playlist_position_and_play(
 705                                       libvlc_media_list_player_t * p_mlp,
 706                                       int i_relative_position,
 707                                       libvlc_exception_t * p_e)
 708 {
 709     assert_locked(p_mlp);
 710
 711     if (!p_mlp->p_mlist)
 712     {
 713         libvlc_exception_raise(p_e);
 714         libvlc_printerr("No media list");
 715         return;
 716     }
 717
 718     libvlc_media_list_lock(p_mlp->p_mlist);
 719
 720     libvlc_media_list_path_t path = p_mlp->current_playing_item_path;
 721
 722     if(p_mlp->e_playback_mode != libvlc_playback_mode_repeat)
 723     {
 724         bool b_loop = (p_mlp->e_playback_mode == libvlc_playback_mode_loop);
 725
 726         if(i_relative_position > 0)
 727         {
 728             do
 729             {
 730                 path = get_next_path(p_mlp, b_loop);
 731                 set_current_playing_item(p_mlp, path);
 732                 --i_relative_position;
 733             }
 734             while(i_relative_position > 0);
 735         }
 736         else if(i_relative_position < 0)
 737         {
 738             do
 739             {
 740                 path = get_previous_path(p_mlp, b_loop);
 741                 set_current_playing_item(p_mlp, path);
 742                 ++i_relative_position;
 743             }
 744             while (i_relative_position < 0);
 745         }
 746     }
 747     else
 748     {
 749         set_current_playing_item(p_mlp, path);
 750     }
 751
 752 #ifdef DEBUG_MEDIA_LIST_PLAYER
 753     printf("Playing:");
 754     libvlc_media_list_path_dump(path);
 755 #endif
 756
 757     if (!path)
 758     {
 759         libvlc_media_list_unlock(p_mlp->p_mlist);
 760         return;
 761     }
 762
 763     libvlc_media_player_play(p_mlp->p_mi, p_e);
 764
 765     libvlc_media_list_unlock(p_mlp->p_mlist);
 766
 767     /* Send the next item event */
 768     libvlc_event_t event;
 769     event.type = libvlc_MediaListPlayerNextItemSet;
 770     libvlc_media_t * p_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, path);
 771     event.u.media_list_player_next_item_set.item = p_md;
 772     libvlc_event_send(p_mlp->p_event_manager, &event);
 773     libvlc_media_release(p_md);
 774 }
 775
 776 /**************************************************************************
 777  *       Next (Public)
 778  **************************************************************************/
 779 void libvlc_media_list_player_next(libvlc_media_list_player_t * p_mlp,
 780                                    libvlc_exception_t * p_e)
 781 {
 782     lock(p_mlp);
 783     set_relative_playlist_position_and_play(p_mlp, 1, p_e);
 784     unlock(p_mlp);
 785 }
 786
 787 /**************************************************************************
 788  *       Previous (Public)
 789  **************************************************************************/
 790 void libvlc_media_list_player_previous(libvlc_media_list_player_t * p_mlp,
 791                                        libvlc_exception_t * p_e)
 792 {
 793     lock(p_mlp);
 794     set_relative_playlist_position_and_play(p_mlp, -1, p_e);
 795     unlock(p_mlp);
 796 }
 797
 798 /**************************************************************************
 799  *       Set Playback Mode (Public)
 800  **************************************************************************/
 801 void libvlc_media_list_player_set_playback_mode(
 802                                             libvlc_media_list_player_t * p_mlp,
 803                                             libvlc_playback_mode_t e_mode,
 804                                             libvlc_exception_t * p_e )
 805 {
 806     VLC_UNUSED(p_e);
 807
 808     lock(p_mlp);
 809     p_mlp->e_playback_mode = e_mode;
 810     unlock(p_mlp);
 811 }