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

   1 /*****************************************************************************
   2  * control.c : Handle control of the playlist & running through it
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 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 "vlc_playlist.h"
  30 #include "playlist_internal.h"
  31 #include <assert.h>
  32
  33 /*****************************************************************************
  34  * Local prototypes
  35  *****************************************************************************/
  36 static int PlaylistVAControl( playlist_t * p_playlist, int i_query, va_list args );
  37
  38 static void PreparseEnqueueItemSub( playlist_t *, playlist_item_t * );
  39
  40 /*****************************************************************************
  41  * Playlist control
  42  *****************************************************************************/
  43
  44 playlist_t *__pl_Hold( vlc_object_t *p_this )
  45 {
  46     playlist_t *pl;
  47
  48     barrier ();
  49     pl = libvlc_priv (p_this->p_libvlc)->p_playlist;
  50
  51     assert( VLC_OBJECT(pl) != p_this /* This does not make sense to hold the playlist
  52     using pl_Hold. use vlc_object_hold in this case */ );
  53
  54     if (pl)
  55         vlc_object_hold (pl);
  56     return pl;
  57 }
  58
  59 void __pl_Release( vlc_object_t *p_this )
  60 {
  61     playlist_t *pl = libvlc_priv (p_this->p_libvlc)->p_playlist;
  62     assert( pl != NULL );
  63
  64     /* The rule is that pl_Release() should act on
  65        the same object than pl_Hold() */
  66     assert( VLC_OBJECT(pl) != p_this);
  67
  68     vlc_object_release( pl );
  69 }
  70
  71 void playlist_Signal( playlist_t *p_playlist )
  72 {
  73     /* TODO: assert playlist lock? */
  74     vlc_object_signal( p_playlist );
  75 }
  76
  77 int playlist_Control( playlist_t * p_playlist, int i_query,
  78                       bool b_locked, ... )
  79 {
  80     va_list args;
  81     int i_result;
  82     va_start( args, b_locked );
  83     PL_LOCK_IF( !b_locked );
  84     i_result = PlaylistVAControl( p_playlist, i_query, args );
  85     va_end( args );
  86     PL_UNLOCK_IF( !b_locked );
  87
  88     return i_result;
  89 }
  90
  91 static int PlaylistVAControl( playlist_t * p_playlist, int i_query, va_list args )
  92 {
  93     playlist_item_t *p_item, *p_node;
  94     vlc_value_t val;
  95
  96     PL_ASSERT_LOCKED;
  97
  98     if( !vlc_object_alive( p_playlist ) )
  99         return VLC_EGENERIC;
 100
 101     if( playlist_IsEmpty( p_playlist ) )
 102         return VLC_EGENERIC;
 103
 104     switch( i_query )
 105     {
 106     case PLAYLIST_STOP:
 107         pl_priv(p_playlist)->request.i_status = PLAYLIST_STOPPED;
 108         pl_priv(p_playlist)->request.b_request = true;
 109         pl_priv(p_playlist)->request.p_item = NULL;
 110         break;
 111
 112     // Node can be null, it will keep the same. Use with care ...
 113     // Item null = take the first child of node
 114     case PLAYLIST_VIEWPLAY:
 115         p_node = (playlist_item_t *)va_arg( args, playlist_item_t * );
 116         p_item = (playlist_item_t *)va_arg( args, playlist_item_t * );
 117         if ( p_node == NULL )
 118         {
 119             p_node = get_current_status_node( p_playlist );
 120             assert( p_node );
 121         }
 122         pl_priv(p_playlist)->request.i_status = PLAYLIST_RUNNING;
 123         pl_priv(p_playlist)->request.i_skip = 0;
 124         pl_priv(p_playlist)->request.b_request = true;
 125         pl_priv(p_playlist)->request.p_node = p_node;
 126         pl_priv(p_playlist)->request.p_item = p_item;
 127         if( p_item && var_GetBool( p_playlist, "random" ) )
 128             pl_priv(p_playlist)->b_reset_currently_playing = true;
 129         break;
 130
 131     case PLAYLIST_PLAY:
 132         if( pl_priv(p_playlist)->p_input )
 133         {
 134             val.i_int = PLAYING_S;
 135             var_Set( pl_priv(p_playlist)->p_input, "state", val );
 136             break;
 137         }
 138         else
 139         {
 140             pl_priv(p_playlist)->request.i_status = PLAYLIST_RUNNING;
 141             pl_priv(p_playlist)->request.b_request = true;
 142             pl_priv(p_playlist)->request.p_node = get_current_status_node( p_playlist );
 143             pl_priv(p_playlist)->request.p_item = get_current_status_item( p_playlist );
 144             pl_priv(p_playlist)->request.i_skip = 0;
 145         }
 146         break;
 147
 148     case PLAYLIST_PAUSE:
 149         val.i_int = 0;
 150         if( pl_priv(p_playlist)->p_input )
 151             var_Get( pl_priv(p_playlist)->p_input, "state", &val );
 152
 153         if( val.i_int == PAUSE_S )
 154         {
 155             pl_priv(p_playlist)->status.i_status = PLAYLIST_RUNNING;
 156             if( pl_priv(p_playlist)->p_input )
 157             {
 158                 val.i_int = PLAYING_S;
 159                 var_Set( pl_priv(p_playlist)->p_input, "state", val );
 160             }
 161         }
 162         else
 163         {
 164             pl_priv(p_playlist)->status.i_status = PLAYLIST_PAUSED;
 165             if( pl_priv(p_playlist)->p_input )
 166             {
 167                 val.i_int = PAUSE_S;
 168                 var_Set( pl_priv(p_playlist)->p_input, "state", val );
 169             }
 170         }
 171         break;
 172
 173     case PLAYLIST_SKIP:
 174         pl_priv(p_playlist)->request.p_node = get_current_status_node( p_playlist );
 175         pl_priv(p_playlist)->request.p_item = get_current_status_item( p_playlist );
 176         pl_priv(p_playlist)->request.i_skip = (int) va_arg( args, int );
 177         /* if already running, keep running */
 178         if( pl_priv(p_playlist)->status.i_status != PLAYLIST_STOPPED )
 179             pl_priv(p_playlist)->request.i_status = pl_priv(p_playlist)->status.i_status;
 180         pl_priv(p_playlist)->request.b_request = true;
 181         break;
 182
 183     default:
 184         msg_Err( p_playlist, "unknown playlist query" );
 185         return VLC_EBADVAR;
 186     }
 187     vlc_object_signal_unlocked( p_playlist );
 188
 189     return VLC_SUCCESS;
 190 }
 191
 192 /*****************************************************************************
 193  * Preparse control
 194  *****************************************************************************/
 195 /** Enqueue an item for preparsing */
 196 int playlist_PreparseEnqueue( playlist_t *p_playlist,
 197                               input_item_t *p_item )
 198 {
 199     playlist_preparse_t *p_preparse = &pl_priv(p_playlist)->preparse;
 200
 201     vlc_gc_incref( p_item );
 202
 203     vlc_mutex_lock( &p_preparse->lock );
 204     INSERT_ELEM( p_preparse->pp_waiting, p_preparse->i_waiting,
 205                  p_preparse->i_waiting, p_item );
 206     vlc_cond_signal( &p_preparse->wait );
 207     vlc_mutex_unlock( &p_preparse->lock );
 208     return VLC_SUCCESS;
 209 }
 210
 211 /** Enqueue a playlist item or a node for preparsing.
 212  *  This function shall be called without playlist and preparser locks */
 213 int playlist_PreparseEnqueueItem( playlist_t *p_playlist,
 214                                   playlist_item_t *p_item )
 215 {
 216     playlist_preparse_t *p_preparse = &pl_priv(p_playlist)->preparse;
 217
 218     vlc_object_lock( p_playlist );
 219     vlc_mutex_lock( &p_preparse->lock );
 220     PreparseEnqueueItemSub( p_playlist, p_item );
 221     vlc_mutex_unlock( &p_preparse->lock );
 222     vlc_object_unlock( p_playlist );
 223     return VLC_SUCCESS;
 224 }
 225
 226 int playlist_AskForArtEnqueue( playlist_t *p_playlist,
 227                                input_item_t *p_item )
 228 {
 229     playlist_fetcher_t *p_fetcher = &pl_priv(p_playlist)->fetcher;
 230
 231     vlc_gc_incref( p_item );
 232
 233     vlc_mutex_lock( &p_fetcher->lock );
 234     INSERT_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting,
 235                  p_fetcher->i_waiting, p_item );
 236     vlc_cond_signal( &p_fetcher->wait );
 237     vlc_mutex_unlock( &p_fetcher->lock );
 238     return VLC_SUCCESS;
 239 }
 240
 241 static void PreparseEnqueueItemSub( playlist_t *p_playlist,
 242                                     playlist_item_t *p_item )
 243 {
 244     playlist_preparse_t *p_preparse = &pl_priv(p_playlist)->preparse;
 245
 246     if( p_item->i_children == -1 )
 247     {
 248         /* Leaf item */
 249         vlc_gc_incref( p_item->p_input );
 250         INSERT_ELEM( p_preparse->pp_waiting,
 251                      p_preparse->i_waiting,
 252                      p_preparse->i_waiting,
 253                      p_item->p_input );
 254     }
 255     else
 256     {
 257         /* Non-leaf item: recurse */
 258         for( int i = 0; i < p_item->i_children; i++)
 259         {
 260             PreparseEnqueueItemSub( p_playlist, p_item->pp_children[i] );
 261         }
 262     }
 263 }
 264
 265 /*****************************************************************************
 266  * Playback logic
 267  *****************************************************************************/
 268
 269 /**
 270  * Synchronise the current index of the playlist
 271  * to match the index of the current item.
 272  *
 273  * \param p_playlist the playlist structure
 274  * \param p_cur the current playlist item
 275  * \return nothing
 276  */
 277 static void ResyncCurrentIndex( playlist_t *p_playlist, playlist_item_t *p_cur )
 278 {
 279      PL_DEBUG( "resyncing on %s", PLI_NAME( p_cur ) );
 280      /* Simply resync index */
 281      int i;
 282      p_playlist->i_current_index = -1;
 283      for( i = 0 ; i< p_playlist->current.i_size; i++ )
 284      {
 285           if( ARRAY_VAL( p_playlist->current, i ) == p_cur )
 286           {
 287               p_playlist->i_current_index = i;
 288               break;
 289           }
 290      }
 291      PL_DEBUG( "%s is at %i", PLI_NAME( p_cur ), p_playlist->i_current_index );
 292 }
 293
 294 void ResetCurrentlyPlaying( playlist_t *p_playlist, bool b_random,
 295                             playlist_item_t *p_cur )
 296 {
 297     playlist_item_t *p_next = NULL;
 298     stats_TimerStart( p_playlist, "Items array build",
 299                       STATS_TIMER_PLAYLIST_BUILD );
 300     PL_DEBUG( "rebuilding array of current - root %s",
 301               PLI_NAME( pl_priv(p_playlist)->status.p_node ) );
 302     ARRAY_RESET( p_playlist->current );
 303     p_playlist->i_current_index = -1;
 304     while( 1 )
 305     {
 306         /** FIXME: this is *slow* */
 307         p_next = playlist_GetNextLeaf( p_playlist,
 308                                        pl_priv(p_playlist)->status.p_node,
 309                                        p_next, true, false );
 310         if( p_next )
 311         {
 312             if( p_next == p_cur )
 313                 p_playlist->i_current_index = p_playlist->current.i_size;
 314             ARRAY_APPEND( p_playlist->current, p_next);
 315         }
 316         else break;
 317     }
 318     PL_DEBUG("rebuild done - %i items, index %i", p_playlist->current.i_size,
 319                                                   p_playlist->i_current_index);
 320     if( b_random )
 321     {
 322         /* Shuffle the array */
 323         srand( (unsigned int)mdate() );
 324         int j;
 325         for( j = p_playlist->current.i_size - 1; j > 0; j-- )
 326         {
 327             int i = rand() % (j+1); /* between 0 and j */
 328             playlist_item_t *p_tmp;
 329             /* swap the two items */
 330             p_tmp = ARRAY_VAL(p_playlist->current, i);
 331             ARRAY_VAL(p_playlist->current,i) = ARRAY_VAL(p_playlist->current,j);
 332             ARRAY_VAL(p_playlist->current,j) = p_tmp;
 333         }
 334     }
 335     pl_priv(p_playlist)->b_reset_currently_playing = false;
 336     stats_TimerStop( p_playlist, STATS_TIMER_PLAYLIST_BUILD );
 337 }
 338
 339 /**
 340  * Compute the next playlist item depending on
 341  * the playlist course mode (forward, backward, random, view,...).
 342  *
 343  * \param p_playlist the playlist object
 344  * \return nothing
 345  */
 346 playlist_item_t * playlist_NextItem( playlist_t *p_playlist )
 347 {
 348     playlist_item_t *p_new = NULL;
 349     int i_skip = 0, i;
 350
 351     bool b_loop = var_GetBool( p_playlist, "loop" );
 352     bool b_random = var_GetBool( p_playlist, "random" );
 353     bool b_repeat = var_GetBool( p_playlist, "repeat" );
 354     bool b_playstop = var_GetBool( p_playlist, "play-and-stop" );
 355
 356     /* Handle quickly a few special cases */
 357     /* No items to play */
 358     if( p_playlist->items.i_size == 0 )
 359     {
 360         msg_Info( p_playlist, "playlist is empty" );
 361         return NULL;
 362     }
 363
 364     /* Repeat and play/stop */
 365     if( !pl_priv(p_playlist)->request.b_request && b_repeat == true &&
 366          get_current_status_item( p_playlist ) )
 367     {
 368         msg_Dbg( p_playlist,"repeating item" );
 369         return get_current_status_item( p_playlist );
 370     }
 371     if( !pl_priv(p_playlist)->request.b_request && b_playstop == true )
 372     {
 373         msg_Dbg( p_playlist,"stopping (play and stop)" );
 374         return NULL;
 375     }
 376
 377     if( !pl_priv(p_playlist)->request.b_request &&
 378         get_current_status_item( p_playlist ) )
 379     {
 380         playlist_item_t *p_parent = get_current_status_item( p_playlist );
 381         while( p_parent )
 382         {
 383             if( p_parent->i_flags & PLAYLIST_SKIP_FLAG )
 384             {
 385                 msg_Dbg( p_playlist, "blocking item, stopping") ;
 386                 return NULL;
 387             }
 388             p_parent = p_parent->p_parent;
 389         }
 390     }
 391
 392     /* Start the real work */
 393     if( pl_priv(p_playlist)->request.b_request )
 394     {
 395         p_new = pl_priv(p_playlist)->request.p_item;
 396         i_skip = pl_priv(p_playlist)->request.i_skip;
 397         PL_DEBUG( "processing request item %s node %s skip %i",
 398                         PLI_NAME( pl_priv(p_playlist)->request.p_item ),
 399                         PLI_NAME( pl_priv(p_playlist)->request.p_node ), i_skip );
 400
 401         if( pl_priv(p_playlist)->request.p_node &&
 402             pl_priv(p_playlist)->request.p_node != get_current_status_node( p_playlist ) )
 403         {
 404
 405             set_current_status_node( p_playlist, pl_priv(p_playlist)->request.p_node );
 406             pl_priv(p_playlist)->request.p_node = NULL;
 407             pl_priv(p_playlist)->b_reset_currently_playing = true;
 408         }
 409
 410         /* If we are asked for a node, go to it's first child */
 411         if( i_skip == 0 && ( p_new == NULL || p_new->i_children != -1 ) )
 412         {
 413             i_skip++;
 414             if( p_new != NULL )
 415             {
 416                 p_new = playlist_GetNextLeaf( p_playlist, p_new, NULL, true, false );
 417                 for( i = 0; i < p_playlist->current.i_size; i++ )
 418                 {
 419                     if( p_new == ARRAY_VAL( p_playlist->current, i ) )
 420                     {
 421                         p_playlist->i_current_index = i;
 422                         i_skip = 0;
 423                     }
 424                 }
 425             }
 426         }
 427
 428         if( pl_priv(p_playlist)->b_reset_currently_playing )
 429             /* A bit too bad to reset twice ... */
 430             ResetCurrentlyPlaying( p_playlist, b_random, p_new );
 431         else if( p_new )
 432             ResyncCurrentIndex( p_playlist, p_new );
 433         else
 434             p_playlist->i_current_index = -1;
 435
 436         if( p_playlist->current.i_size && (i_skip > 0) )
 437         {
 438             if( p_playlist->i_current_index < -1 )
 439                 p_playlist->i_current_index = -1;
 440             for( i = i_skip; i > 0 ; i-- )
 441             {
 442                 p_playlist->i_current_index++;
 443                 if( p_playlist->i_current_index >= p_playlist->current.i_size )
 444                 {
 445                     PL_DEBUG( "looping - restarting at beginning of node" );
 446                     p_playlist->i_current_index = 0;
 447                 }
 448             }
 449             p_new = ARRAY_VAL( p_playlist->current,
 450                                p_playlist->i_current_index );
 451         }
 452         else if( p_playlist->current.i_size && (i_skip < 0) )
 453         {
 454             for( i = i_skip; i < 0 ; i++ )
 455             {
 456                 p_playlist->i_current_index--;
 457                 if( p_playlist->i_current_index <= -1 )
 458                 {
 459                     PL_DEBUG( "looping - restarting at end of node" );
 460                     p_playlist->i_current_index = p_playlist->current.i_size-1;
 461                 }
 462             }
 463             p_new = ARRAY_VAL( p_playlist->current,
 464                                p_playlist->i_current_index );
 465         }
 466         /* Clear the request */
 467         pl_priv(p_playlist)->request.b_request = false;
 468     }
 469     /* "Automatic" item change ( next ) */
 470     else
 471     {
 472         PL_DEBUG( "changing item without a request (current %i/%i)",
 473                   p_playlist->i_current_index, p_playlist->current.i_size );
 474         /* Cant go to next from current item */
 475         if( get_current_status_item( p_playlist ) &&
 476             get_current_status_item( p_playlist )->i_flags & PLAYLIST_SKIP_FLAG )
 477             return NULL;
 478
 479         if( pl_priv(p_playlist)->b_reset_currently_playing )
 480             ResetCurrentlyPlaying( p_playlist, b_random,
 481                                    get_current_status_item( p_playlist ) );
 482
 483         p_playlist->i_current_index++;
 484         assert( p_playlist->i_current_index <= p_playlist->current.i_size );
 485         if( p_playlist->i_current_index == p_playlist->current.i_size )
 486         {
 487             if( !b_loop || p_playlist->current.i_size == 0 ) return NULL;
 488             p_playlist->i_current_index = 0;
 489         }
 490         PL_DEBUG( "using item %i", p_playlist->i_current_index );
 491         if ( p_playlist->current.i_size == 0 ) return NULL;
 492
 493         p_new = ARRAY_VAL( p_playlist->current, p_playlist->i_current_index );
 494         /* The new item can't be autoselected  */
 495         if( p_new != NULL && p_new->i_flags & PLAYLIST_SKIP_FLAG )
 496             return NULL;
 497     }
 498     return p_new;
 499 }
 500
 501 /**
 502  * Start the input for an item
 503  *
 504  * \param p_playlist the playlist object
 505  * \param p_item the item to play
 506  * \return nothing
 507  */
 508 int playlist_PlayItem( playlist_t *p_playlist, playlist_item_t *p_item )
 509 {
 510     input_item_t *p_input = p_item->p_input;
 511     sout_instance_t **pp_sout = &pl_priv(p_playlist)->p_sout;
 512     int i_activity = var_GetInteger( p_playlist, "activity" ) ;
 513
 514     msg_Dbg( p_playlist, "creating new input thread" );
 515
 516     p_input->i_nb_played++;
 517     set_current_status_item( p_playlist, p_item );
 518
 519     pl_priv(p_playlist)->status.i_status = PLAYLIST_RUNNING;
 520
 521     var_SetInteger( p_playlist, "activity", i_activity +
 522                     DEFAULT_INPUT_ACTIVITY );
 523
 524     input_thread_t * p_input_thread =
 525         input_CreateThreadExtended( p_playlist, p_input, NULL, *pp_sout );
 526     playlist_set_current_input( p_playlist, p_input_thread );
 527     vlc_object_release( p_input_thread );
 528
 529     *pp_sout = NULL;
 530
 531     char *psz_uri = input_item_GetURI( p_item->p_input );
 532     if( psz_uri && ( !strncmp( psz_uri, "directory:", 10 ) ||
 533                      !strncmp( psz_uri, "vlc:", 4 ) ) )
 534     {
 535         free( psz_uri );
 536         return VLC_SUCCESS;
 537     }
 538     free( psz_uri );
 539
 540     if( pl_priv(p_playlist)->fetcher.i_art_policy == ALBUM_ART_WHEN_PLAYED )
 541     {
 542         bool b_has_art;
 543
 544         char *psz_arturl, *psz_name;
 545         psz_arturl = input_item_GetArtURL( p_input );
 546         psz_name = input_item_GetName( p_input );
 547
 548         /* p_input->p_meta should not be null after a successfull CreateThread */
 549         b_has_art = !EMPTY_STR( psz_arturl );
 550
 551         if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) )
 552         {
 553             PL_DEBUG( "requesting art for %s", psz_name );
 554             playlist_AskForArtEnqueue( p_playlist, p_input );
 555         }
 556         free( psz_arturl );
 557         free( psz_name );
 558     }
 559
 560     PL_UNLOCK;
 561     var_SetInteger( p_playlist, "playlist-current", p_input->i_id );
 562     PL_LOCK;
 563
 564     return VLC_SUCCESS;
 565 }