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 #include <vlc/libvlc.h>
  25 #include <vlc/libvlc_media.h>
  26 #include <vlc/libvlc_media_list.h>
  27 #include <vlc/libvlc_media_player.h>
  28 #include <vlc/libvlc_media_list_player.h>
  29 #include <vlc/libvlc_events.h>
  30
  31 #include "libvlc_internal.h"
  32
  33 #include "media_internal.h" // Abuse, could and should be removed
  34 #include "media_list_path.h"
  35
  36 //#define DEBUG_MEDIA_LIST_PLAYER
  37
  38 struct libvlc_media_list_player_t
  39 {
  40     libvlc_event_manager_t *    p_event_manager;
  41     libvlc_instance_t *         p_libvlc_instance;
  42     int                         i_refcount;
  43     vlc_mutex_t                 object_lock;
  44     libvlc_media_list_path_t    current_playing_item_path;
  45     libvlc_media_t *            p_current_playing_item;
  46     libvlc_media_list_t *       p_mlist;
  47     libvlc_media_player_t *     p_mi;
  48 };
  49
  50 /*
  51  * Private functions
  52  */
  53
  54 /**************************************************************************
  55  *       get_next_index (private)
  56  *
  57  * Simple next item fetcher.
  58  **************************************************************************/
  59 static libvlc_media_list_path_t
  60 get_next_path( libvlc_media_list_player_t * p_mlp )
  61 {
  62     /* We are entered with libvlc_media_list_lock( p_mlp->p_list ) */
  63     libvlc_media_list_path_t ret;
  64     libvlc_media_list_t * p_parent_of_playing_item;
  65     libvlc_media_list_t * p_sublist_of_playing_item;
  66
  67     if ( !p_mlp->current_playing_item_path )
  68     {
  69         if( !libvlc_media_list_count( p_mlp->p_mlist, NULL ) )
  70             return NULL;
  71         return libvlc_media_list_path_with_root_index(0);
  72     }
  73
  74     p_sublist_of_playing_item = libvlc_media_list_sublist_at_path(
  75                             p_mlp->p_mlist,
  76                             p_mlp->current_playing_item_path );
  77
  78     /* If item just gained a sublist just play it */
  79     if( p_sublist_of_playing_item )
  80     {
  81         libvlc_media_list_release( p_sublist_of_playing_item );
  82         return libvlc_media_list_path_copy_by_appending( p_mlp->current_playing_item_path, 0 );
  83     }
  84
  85     /* Try to catch next element */
  86     p_parent_of_playing_item = libvlc_media_list_parentlist_at_path(
  87                             p_mlp->p_mlist,
  88                             p_mlp->current_playing_item_path );
  89
  90     int depth = libvlc_media_list_path_depth( p_mlp->current_playing_item_path );
  91     if( depth < 1 || !p_parent_of_playing_item )
  92         return NULL;
  93
  94     ret = libvlc_media_list_path_copy( p_mlp->current_playing_item_path );
  95
  96     ret[depth-1]++; // Play next element
  97
  98     /* If this goes beyong the end of the list */
  99     while( ret[depth-1] >= libvlc_media_list_count( p_parent_of_playing_item, NULL ) )
 100     {
 101         depth--;
 102         if( depth <= 0 )
 103         {
 104             free( ret );
 105             libvlc_media_list_release( p_parent_of_playing_item );
 106             return NULL;
 107         }
 108         ret[depth] = -1;
 109         ret[depth-1]++;
 110         p_parent_of_playing_item  = libvlc_media_list_parentlist_at_path(
 111                                         p_mlp->p_mlist,
 112                                         ret );
 113     }
 114     libvlc_media_list_release( p_parent_of_playing_item );
 115     return ret;
 116 }
 117
 118 /**************************************************************************
 119  *       media_player_reached_end (private) (Event Callback)
 120  **************************************************************************/
 121 static void
 122 media_player_reached_end( const libvlc_event_t * p_event,
 123                             void * p_user_data )
 124 {
 125     libvlc_media_list_player_t * p_mlp = p_user_data;
 126     libvlc_media_player_t * p_mi = p_event->p_obj;
 127     libvlc_media_t *p_md, * p_current_md;
 128
 129     p_md = libvlc_media_player_get_media( p_mi, NULL );
 130     /* XXX: need if p_mlp->p_current_playing_index is beyond */
 131     p_current_md = libvlc_media_list_item_at_path(
 132                         p_mlp->p_mlist,
 133                         p_mlp->current_playing_item_path );
 134     if( p_md != p_current_md )
 135     {
 136         msg_Warn( p_mlp->p_libvlc_instance->p_libvlc_int,
 137                   "We are not sync-ed with the media instance" );
 138         libvlc_media_release( p_md );
 139         libvlc_media_release( p_current_md );
 140         return;
 141     }
 142     libvlc_media_release( p_md );
 143     libvlc_media_release( p_current_md );
 144     libvlc_exception_t e;
 145     libvlc_exception_init(&e);
 146     libvlc_media_list_player_next(p_mlp, &e);
 147     libvlc_exception_clear(&e); // Don't worry if there was an error
 148 }
 149
 150 /**************************************************************************
 151  *       playlist_item_deleted (private) (Event Callback)
 152  **************************************************************************/
 153 static void
 154 mlist_item_deleted( const libvlc_event_t * p_event, void * p_user_data )
 155 {
 156     libvlc_media_t * p_current_md;
 157     libvlc_media_list_player_t * p_mlp = p_user_data;
 158     libvlc_media_list_t * p_emitting_mlist = p_event->p_obj;
 159     /* XXX: need if p_mlp->p_current_playing_index is beyond */
 160     p_current_md = libvlc_media_list_item_at_path(
 161                         p_mlp->p_mlist,
 162                         p_mlp->current_playing_item_path );
 163
 164     if( p_event->u.media_list_item_deleted.item == p_current_md &&
 165         p_emitting_mlist == p_mlp->p_mlist )
 166     {
 167         /* We are playing this item, we choose to stop */
 168         libvlc_media_list_player_stop( p_mlp, NULL );
 169     }
 170 }
 171
 172 /**************************************************************************
 173  *       install_playlist_observer (private)
 174  **************************************************************************/
 175 static void
 176 install_playlist_observer( libvlc_media_list_player_t * p_mlp )
 177 {
 178     libvlc_event_attach( libvlc_media_list_event_manager( p_mlp->p_mlist, NULL ),
 179             libvlc_MediaListItemDeleted, mlist_item_deleted, p_mlp, NULL );
 180 }
 181
 182 /**************************************************************************
 183  *       uninstall_playlist_observer (private)
 184  **************************************************************************/
 185 static void
 186 uninstall_playlist_observer( libvlc_media_list_player_t * p_mlp )
 187 {
 188     if ( !p_mlp->p_mlist )
 189     {
 190         return;
 191     }
 192
 193     libvlc_event_detach( libvlc_media_list_event_manager( p_mlp->p_mlist, NULL ),
 194             libvlc_MediaListItemDeleted, mlist_item_deleted, p_mlp, NULL );
 195 }
 196
 197 /**************************************************************************
 198  *       install_media_player_observer (private)
 199  **************************************************************************/
 200 static void
 201 install_media_player_observer( libvlc_media_list_player_t * p_mlp )
 202 {
 203     libvlc_event_attach_async( libvlc_media_player_event_manager( p_mlp->p_mi, NULL ),
 204                          libvlc_MediaPlayerEndReached,
 205                           media_player_reached_end, p_mlp, NULL );
 206 }
 207
 208
 209 /**************************************************************************
 210  *       uninstall_media_player_observer (private)
 211  **************************************************************************/
 212 static void
 213 uninstall_media_player_observer( libvlc_media_list_player_t * p_mlp )
 214 {
 215     if ( !p_mlp->p_mi )
 216         return;
 217
 218     libvlc_event_detach( libvlc_media_player_event_manager( p_mlp->p_mi, NULL ),
 219                          libvlc_MediaPlayerEndReached,
 220                          media_player_reached_end, p_mlp, NULL );
 221 }
 222
 223 /**************************************************************************
 224  *       set_current_playing_item (private)
 225  *
 226  * Playlist lock should be held
 227  **************************************************************************/
 228 static void
 229 set_current_playing_item( libvlc_media_list_player_t * p_mlp,
 230                           libvlc_media_list_path_t path,
 231                           libvlc_exception_t * p_e )
 232 {
 233     VLC_UNUSED(p_e);
 234
 235     libvlc_media_t * p_md;
 236
 237     p_md = libvlc_media_list_item_at_path( p_mlp->p_mlist, path );
 238     vlc_mutex_lock( &p_mlp->object_lock );
 239
 240     if( p_mlp->current_playing_item_path != path )
 241     {
 242         free( p_mlp->current_playing_item_path );
 243         p_mlp->current_playing_item_path = path;
 244     }
 245
 246     if( !p_md )
 247     {
 248         vlc_mutex_unlock( &p_mlp->object_lock );
 249         return;
 250     }
 251
 252     /* We are not interested in getting media stop event now */
 253     uninstall_media_player_observer( p_mlp );
 254
 255     if ( !p_mlp->p_mi )
 256     {
 257         p_mlp->p_mi = libvlc_media_player_new_from_media(p_md, p_e);
 258     }
 259
 260     if( p_md->p_subitems && libvlc_media_list_count( p_md->p_subitems, NULL ) > 0 )
 261     {
 262         libvlc_media_t * p_submd;
 263         p_submd = libvlc_media_list_item_at_index( p_md->p_subitems, 0, NULL );
 264         libvlc_media_player_set_media( p_mlp->p_mi, p_submd, NULL );
 265         libvlc_media_release( p_submd );
 266     }
 267     else
 268         libvlc_media_player_set_media( p_mlp->p_mi, p_md, NULL );
 269 //    wait_playing_state(); /* If we want to be synchronous */
 270     install_media_player_observer( p_mlp );
 271
 272     vlc_mutex_unlock( &p_mlp->object_lock );
 273
 274     libvlc_media_release( p_md ); /* for libvlc_media_list_item_at_index */
 275 }
 276
 277 /*
 278  * Public libvlc functions
 279  */
 280
 281 /**************************************************************************
 282  *         new (Public)
 283  **************************************************************************/
 284 libvlc_media_list_player_t *
 285 libvlc_media_list_player_new( libvlc_instance_t * p_instance,
 286                               libvlc_exception_t * p_e )
 287 {
 288     (void)p_e;
 289     libvlc_media_list_player_t * p_mlp;
 290     p_mlp = malloc(sizeof(libvlc_media_list_player_t));
 291     if( !p_mlp )
 292         return NULL;
 293
 294     libvlc_retain( p_instance );
 295     p_mlp->p_libvlc_instance = p_instance;
 296     p_mlp->i_refcount = 0;
 297     vlc_mutex_init( &p_mlp->object_lock );
 298     p_mlp->current_playing_item_path = NULL;
 299     p_mlp->p_mlist = NULL;
 300     p_mlp->p_mi = NULL;
 301     p_mlp->p_event_manager = libvlc_event_manager_new( p_mlp,
 302                                                        p_instance,
 303                                                        p_e );
 304     libvlc_event_manager_register_event_type( p_mlp->p_event_manager,
 305             libvlc_MediaListPlayerNextItemSet, p_e );
 306
 307     return p_mlp;
 308 }
 309
 310 /**************************************************************************
 311  *         release (Public)
 312  **************************************************************************/
 313 void libvlc_media_list_player_release( libvlc_media_list_player_t * p_mlp )
 314 {
 315     if( !p_mlp )
 316         return;
 317
 318     vlc_mutex_lock( &p_mlp->object_lock );
 319
 320     p_mlp->i_refcount--;
 321     if( p_mlp->i_refcount > 0 )
 322     {
 323         vlc_mutex_unlock( &p_mlp->object_lock );
 324         return;
 325     }
 326     vlc_mutex_unlock( &p_mlp->object_lock );
 327     vlc_mutex_destroy( &p_mlp->object_lock );
 328
 329     libvlc_event_manager_release( p_mlp->p_event_manager );
 330     libvlc_media_player_release( p_mlp->p_mi );
 331
 332     if( p_mlp->p_mlist )
 333     {
 334         uninstall_playlist_observer( p_mlp );
 335         libvlc_media_list_release( p_mlp->p_mlist );
 336     }
 337
 338     free( p_mlp->current_playing_item_path );
 339     libvlc_release( p_mlp->p_libvlc_instance );
 340     free( p_mlp );
 341 }
 342
 343 /**************************************************************************
 344  *        set_media_player (Public)
 345  **************************************************************************/
 346 void libvlc_media_list_player_set_media_player(
 347                                      libvlc_media_list_player_t * p_mlp,
 348                                      libvlc_media_player_t * p_mi,
 349                                      libvlc_exception_t * p_e )
 350 {
 351     VLC_UNUSED(p_e);
 352
 353     vlc_mutex_lock( &p_mlp->object_lock );
 354
 355     if( p_mlp->p_mi )
 356     {
 357         uninstall_media_player_observer( p_mlp );
 358         libvlc_media_player_release( p_mlp->p_mi );
 359     }
 360     libvlc_media_player_retain( p_mi );
 361     p_mlp->p_mi = p_mi;
 362
 363     install_media_player_observer( p_mlp );
 364
 365     vlc_mutex_unlock( &p_mlp->object_lock );
 366 }
 367
 368 /**************************************************************************
 369  *       set_media_list (Public)
 370  **************************************************************************/
 371 void libvlc_media_list_player_set_media_list(
 372                                      libvlc_media_list_player_t * p_mlp,
 373                                      libvlc_media_list_t * p_mlist,
 374                                      libvlc_exception_t * p_e )
 375 {
 376     vlc_mutex_lock( &p_mlp->object_lock );
 377
 378     if(!p_mlist)
 379     {
 380         libvlc_exception_raise( p_e, "No media list provided");
 381         vlc_mutex_unlock( &p_mlp->object_lock );
 382         return;
 383     }
 384
 385     if( libvlc_media_list_player_is_playing( p_mlp, p_e ) )
 386     {
 387         libvlc_media_player_stop( p_mlp->p_mi, p_e );
 388         /* Don't bother if there was an error. */
 389         libvlc_exception_clear( p_e );
 390     }
 391
 392     if( p_mlp->p_mlist )
 393     {
 394         uninstall_playlist_observer( p_mlp );
 395         libvlc_media_list_release( p_mlp->p_mlist );
 396     }
 397     libvlc_media_list_retain( p_mlist );
 398     p_mlp->p_mlist = p_mlist;
 399
 400     install_playlist_observer( p_mlp );
 401
 402     vlc_mutex_unlock( &p_mlp->object_lock );
 403 }
 404
 405 /**************************************************************************
 406  *        Play (Public)
 407  **************************************************************************/
 408 void libvlc_media_list_player_play( libvlc_media_list_player_t * p_mlp,
 409                                   libvlc_exception_t * p_e )
 410 {
 411     if( !p_mlp->current_playing_item_path )
 412     {
 413         libvlc_media_list_player_next( p_mlp, p_e );
 414         return; /* Will set to play */
 415     }
 416
 417     libvlc_media_player_play( p_mlp->p_mi, p_e );
 418 }
 419
 420
 421 /**************************************************************************
 422  *        Pause (Public)
 423  **************************************************************************/
 424 void libvlc_media_list_player_pause( libvlc_media_list_player_t * p_mlp,
 425                                      libvlc_exception_t * p_e )
 426 {
 427     if( !p_mlp->p_mi )
 428         return;
 429     libvlc_media_player_pause( p_mlp->p_mi, p_e );
 430 }
 431
 432 /**************************************************************************
 433  *        is_playing (Public)
 434  **************************************************************************/
 435 int
 436 libvlc_media_list_player_is_playing( libvlc_media_list_player_t * p_mlp,
 437                                      libvlc_exception_t * p_e )
 438 {
 439     enum libvlc_state_t state;
 440
 441     state = libvlc_media_player_get_state( p_mlp->p_mi, p_e );
 442     return (state == libvlc_Opening) || (state == libvlc_Buffering) ||
 443            (state == libvlc_Playing);
 444 }
 445
 446 /**************************************************************************
 447  *        State (Public)
 448  **************************************************************************/
 449 enum libvlc_state_t
 450 libvlc_media_list_player_get_state( libvlc_media_list_player_t * p_mlp,
 451                                     libvlc_exception_t * p_e )
 452 {
 453     if( !p_mlp->p_mi )
 454         return libvlc_Ended;
 455     return libvlc_media_player_get_state( p_mlp->p_mi, p_e );
 456 }
 457
 458 /**************************************************************************
 459  *        Play item at index (Public)
 460  **************************************************************************/
 461 void libvlc_media_list_player_play_item_at_index(
 462                         libvlc_media_list_player_t * p_mlp,
 463                         int i_index,
 464                         libvlc_exception_t * p_e )
 465 {
 466     set_current_playing_item( p_mlp, libvlc_media_list_path_with_root_index(i_index), p_e );
 467
 468     if( libvlc_exception_raised( p_e ) )
 469         return;
 470
 471     /* Send the next item event */
 472     libvlc_event_t event;
 473     event.type = libvlc_MediaListPlayerNextItemSet;
 474     libvlc_event_send( p_mlp->p_event_manager, &event );
 475
 476     libvlc_media_player_play( p_mlp->p_mi, p_e );
 477 }
 478
 479 /**************************************************************************
 480  *        Play item (Public)
 481  **************************************************************************/
 482 void libvlc_media_list_player_play_item(
 483                         libvlc_media_list_player_t * p_mlp,
 484                         libvlc_media_t * p_md,
 485                         libvlc_exception_t * p_e )
 486 {
 487     libvlc_media_list_path_t path = libvlc_media_list_path_of_item( p_mlp->p_mlist, p_md );
 488     if( !path )
 489     {
 490         libvlc_exception_raise( p_e, "No such item in media list" );
 491         return;
 492     }
 493     set_current_playing_item( p_mlp, path, p_e );
 494
 495     if( libvlc_exception_raised( p_e ) )
 496         return;
 497
 498     libvlc_media_player_play( p_mlp->p_mi, p_e );
 499 }
 500
 501 /**************************************************************************
 502  *       Stop (Public)
 503  **************************************************************************/
 504 void libvlc_media_list_player_stop( libvlc_media_list_player_t * p_mlp,
 505                                     libvlc_exception_t * p_e )
 506 {
 507     vlc_mutex_lock( &p_mlp->object_lock );
 508
 509     if ( p_mlp->p_mi )
 510     {
 511         /* We are not interested in getting media stop event now */
 512         uninstall_media_player_observer( p_mlp );
 513         libvlc_media_player_stop( p_mlp->p_mi, p_e );
 514         install_media_player_observer( p_mlp );
 515     }
 516
 517     free( p_mlp->current_playing_item_path );
 518     p_mlp->current_playing_item_path = NULL;
 519     vlc_mutex_unlock( &p_mlp->object_lock );
 520 }
 521
 522 /**************************************************************************
 523  *       Next (Public)
 524  **************************************************************************/
 525 void libvlc_media_list_player_next( libvlc_media_list_player_t * p_mlp,
 526                                     libvlc_exception_t * p_e )
 527 {
 528     libvlc_media_list_path_t path;
 529
 530     if (! p_mlp->p_mlist )
 531     {
 532         libvlc_exception_raise( p_e, "No media list" );
 533         return;
 534     }
 535
 536     libvlc_media_list_lock( p_mlp->p_mlist );
 537
 538     path = get_next_path( p_mlp );
 539
 540 #ifdef DEBUG_MEDIA_LIST_PLAYER
 541     printf("Playing:");
 542     libvlc_media_list_path_dump(path);
 543 #endif
 544
 545     if( !path )
 546     {
 547         libvlc_media_list_unlock( p_mlp->p_mlist );
 548         libvlc_exception_raise( p_e, "No more element to play" );
 549         libvlc_media_list_player_stop( p_mlp, p_e );
 550         return;
 551     }
 552
 553     set_current_playing_item( p_mlp, path, p_e );
 554
 555     libvlc_media_player_play( p_mlp->p_mi, p_e );
 556
 557     libvlc_media_list_unlock( p_mlp->p_mlist );
 558
 559     /* Send the next item event */
 560     libvlc_event_t event;
 561     event.type = libvlc_MediaListPlayerNextItemSet;
 562     libvlc_event_send( p_mlp->p_event_manager, &event);
 563 }