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