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