src/playlist_legacy/engine.c

   1 /*****************************************************************************
   2  * engine.c : Run the playlist and handle its control
   3  *****************************************************************************
   4  * Copyright (C) 1999-2008 VLC authors and VideoLAN
   5  *
   6  * Authors: Samuel Hocevar <sam@zoy.org>
   7  *          Clément Stenac <zorglub@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * 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 <stddef.h>
  29 #include <assert.h>
  30
  31 #include <vlc_common.h>
  32 #include <vlc_arrays.h>
  33 #include <vlc_sout.h>
  34 #include <vlc_playlist_legacy.h>
  35 #include <vlc_interface.h>
  36 #include <vlc_http.h>
  37 #include <vlc_renderer_discovery.h>
  38 #include "playlist_internal.h"
  39 #include "input/resource.h"
  40
  41 /*****************************************************************************
  42  * Local prototypes
  43  *****************************************************************************/
  44 static void VariablesInit( playlist_t *p_playlist );
  45
  46 static int RandomCallback( vlc_object_t *p_this, char const *psz_cmd,
  47                            vlc_value_t oldval, vlc_value_t newval, void *a )
  48 {
  49     (void)psz_cmd; (void)oldval; (void)newval; (void)a;
  50     playlist_t *p_playlist = (playlist_t*)p_this;
  51     bool random = newval.b_bool;
  52
  53     PL_LOCK;
  54
  55     if( !random ) {
  56         pl_priv(p_playlist)->b_reset_currently_playing = true;
  57         vlc_cond_signal( &pl_priv(p_playlist)->signal );
  58     } else {
  59         /* Shuffle and sync the playlist on activation of random mode.
  60          * This preserves the current playing item, so that the user
  61          * can return to it if needed. (See #4472)
  62          */
  63         playlist_private_t *p_sys = pl_priv(p_playlist);
  64         playlist_item_t *p_new = p_sys->status.p_item;
  65         ResetCurrentlyPlaying( p_playlist, NULL );
  66         if( p_new )
  67             ResyncCurrentIndex( p_playlist, p_new );
  68     }
  69
  70     PL_UNLOCK;
  71     return VLC_SUCCESS;
  72 }
  73
  74 /**
  75  * When there are one or more pending corks, playback should be paused.
  76  * This is used for audio policy.
  77  * \warning Always add and remove a cork with var_IncInteger() and var_DecInteger().
  78  * var_Get() and var_Set() are prone to race conditions.
  79  */
  80 static int CorksCallback( vlc_object_t *obj, char const *var,
  81                           vlc_value_t old, vlc_value_t cur, void *dummy )
  82 {
  83     playlist_t *pl = (playlist_t *)obj;
  84
  85     msg_Dbg( obj, "corks count: %"PRId64" -> %"PRId64, old.i_int, cur.i_int );
  86     if( !old.i_int == !cur.i_int )
  87         return VLC_SUCCESS; /* nothing to do */
  88
  89     if( !var_InheritBool( obj, "playlist-cork" ) )
  90         return VLC_SUCCESS;
  91
  92     playlist_Lock(pl);
  93
  94     if( cur.i_int )
  95     {
  96         bool effective = playlist_Status(pl) == PLAYLIST_RUNNING;
  97
  98         msg_Dbg(obj, "corked (%seffective)", effective ? "" : "in");
  99         pl_priv(pl)->cork_effective = effective;
 100         playlist_Control(pl, PLAYLIST_PAUSE, pl_Locked);
 101     }
 102     else
 103     {
 104         bool effective = pl_priv(pl)->cork_effective;
 105
 106         msg_Dbg(obj, "uncorked (%seffective)", effective ? "" : "in");
 107
 108         if (effective)
 109             playlist_Control(pl, PLAYLIST_RESUME, pl_Locked);
 110     }
 111
 112     playlist_Unlock(pl);
 113     (void) var; (void) dummy;
 114     return VLC_SUCCESS;
 115 }
 116
 117 static int RateCallback( vlc_object_t *p_this, char const *psz_cmd,
 118                          vlc_value_t oldval, vlc_value_t newval, void *p )
 119 {
 120     (void)psz_cmd; (void)oldval;(void)p;
 121     playlist_t *p_playlist = (playlist_t*)p_this;
 122
 123     PL_LOCK;
 124
 125     if( pl_priv(p_playlist)->p_input )
 126         var_SetFloat( pl_priv( p_playlist )->p_input, "rate", newval.f_float );
 127
 128     PL_UNLOCK;
 129     return VLC_SUCCESS;
 130 }
 131
 132 static int RateOffsetCallback( vlc_object_t *obj, char const *psz_cmd,
 133                                vlc_value_t oldval, vlc_value_t newval, void *p_data )
 134 {
 135     playlist_t *p_playlist = (playlist_t *)obj;
 136     VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval);
 137
 138     static const float rates[] = {
 139         1.0/64, 1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0/3, 1.0/2, 2.0/3,
 140         1.0/1,
 141         3.0/2, 2.0/1, 3.0/1, 4.0/1, 8.0/1, 16.0/1, 32.0/1, 64.0/1,
 142     };
 143
 144     PL_LOCK;
 145     input_thread_t *input = pl_priv( p_playlist )->p_input;
 146     float current_rate = var_GetFloat( input ? VLC_OBJECT( input ) : obj, "rate" );
 147     PL_UNLOCK;
 148
 149     const bool faster = !strcmp( psz_cmd, "rate-faster" );
 150     float rate = current_rate * ( faster ? 1.1f : 0.9f );
 151
 152     /* find closest rate (if any) in the desired direction */
 153     for( size_t i = 0; i < ARRAY_SIZE( rates ); ++i )
 154     {
 155         if( ( faster && rates[i] > rate ) ||
 156             (!faster && rates[i] >= rate && i ) )
 157         {
 158             rate = faster ? rates[i] : rates[i-1];
 159             break;
 160         }
 161     }
 162
 163     msg_Dbg( p_playlist, "adjusting rate from %f to %f (%s)",
 164         current_rate, rate, faster ? "faster" : "slower" );
 165
 166     return var_SetFloat( p_playlist, "rate", rate );
 167 }
 168
 169 static int VideoSplitterCallback( vlc_object_t *p_this, char const *psz_cmd,
 170                                   vlc_value_t oldval, vlc_value_t newval, void *p_data )
 171 {
 172     playlist_t *p_playlist = (playlist_t*)p_this;
 173     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval);
 174
 175     PL_LOCK;
 176
 177     /* Force the input to restart the video ES to force a vout recreation */
 178     input_thread_t *p_input = pl_priv( p_playlist )->p_input;
 179     if( p_input )
 180     {
 181         const double f_position = var_GetFloat( p_input, "position" );
 182         input_Control( p_input, INPUT_RESTART_ES_BY_ID, -VIDEO_ES );
 183         var_SetFloat( p_input, "position", f_position );
 184     }
 185
 186     PL_UNLOCK;
 187     return VLC_SUCCESS;
 188 }
 189
 190 /**
 191  * Create playlist
 192  *
 193  * Create a playlist structure.
 194  * \param p_parent the vlc object that is to be the parent of this playlist
 195  * \return a pointer to the created playlist, or NULL on error
 196  */
 197 playlist_t *playlist_Create( vlc_object_t *p_parent )
 198 {
 199     playlist_t *p_playlist;
 200     playlist_private_t *p;
 201
 202     /* Allocate structure */
 203     p = vlc_custom_create( p_parent, sizeof( *p ), "playlist" );
 204     if( !p )
 205         return NULL;
 206
 207     p_playlist = &p->public_data;
 208
 209     p->input_tree = NULL;
 210     p->id_tree = NULL;
 211
 212     vlc_list_init(&p->sds);
 213
 214     VariablesInit( p_playlist );
 215     vlc_mutex_init( &p->lock );
 216     vlc_cond_init( &p->signal );
 217     p->killed = false;
 218
 219     /* Initialise data structures */
 220     pl_priv(p_playlist)->i_last_playlist_id = 0;
 221     pl_priv(p_playlist)->p_input = NULL;
 222
 223     ARRAY_INIT( p_playlist->items );
 224     ARRAY_INIT( p_playlist->current );
 225
 226     p_playlist->i_current_index = 0;
 227     pl_priv(p_playlist)->b_reset_currently_playing = true;
 228
 229     pl_priv(p_playlist)->b_tree = var_InheritBool( p_parent, "playlist-tree" );
 230     pl_priv(p_playlist)->b_preparse = var_InheritBool( p_parent, "auto-preparse" );
 231
 232     p_playlist->root.p_input = NULL;
 233     p_playlist->root.pp_children = NULL;
 234     p_playlist->root.i_children = 0;
 235     p_playlist->root.i_nb_played = 0;
 236     p_playlist->root.i_id = 0;
 237     p_playlist->root.i_flags = 0;
 238
 239     /* Create the root, playing items nodes */
 240     playlist_item_t *playing;
 241
 242     PL_LOCK;
 243     playing = playlist_NodeCreate( p_playlist, _( "Playlist" ),
 244                                    &p_playlist->root, PLAYLIST_END,
 245                                    PLAYLIST_RO_FLAG|PLAYLIST_NO_INHERIT_FLAG );
 246     PL_UNLOCK;
 247
 248     if( unlikely(playing == NULL) )
 249         abort();
 250
 251     p_playlist->p_playing = playing;
 252
 253     /* Initial status */
 254     pl_priv(p_playlist)->status.p_item = NULL;
 255     pl_priv(p_playlist)->status.p_node = p_playlist->p_playing;
 256     pl_priv(p_playlist)->request.b_request = false;
 257     p->request.input_dead = false;
 258
 259     /* Input resources */
 260     p->p_input_resource = input_resource_New( VLC_OBJECT( p_playlist ) );
 261     if( unlikely(p->p_input_resource == NULL) )
 262         abort();
 263
 264     /* Audio output (needed for volume and device controls). */
 265     audio_output_t *aout = input_resource_GetAout( p->p_input_resource );
 266     if( aout != NULL )
 267         input_resource_PutAout( p->p_input_resource, aout );
 268
 269     /* Initialize the shared HTTP cookie jar */
 270     vlc_value_t cookies;
 271     cookies.p_address = vlc_http_cookies_new();
 272     if ( likely(cookies.p_address) )
 273     {
 274         var_Create( p_playlist, "http-cookies", VLC_VAR_ADDRESS );
 275         var_SetChecked( p_playlist, "http-cookies", VLC_VAR_ADDRESS, cookies );
 276     }
 277
 278     /* Thread */
 279     playlist_Activate (p_playlist);
 280
 281     /* Add service discovery modules */
 282     char *mods = var_InheritString( p_playlist, "services-discovery" );
 283     if( mods != NULL )
 284     {
 285         char *s = mods, *m;
 286         while( (m = strsep( &s, " :," )) != NULL )
 287             playlist_ServicesDiscoveryAdd( p_playlist, m );
 288         free( mods );
 289     }
 290
 291     return p_playlist;
 292 }
 293
 294 /**
 295  * Destroy playlist.
 296  * This is not thread-safe. Any reference to the playlist is assumed gone.
 297  * (In particular, all interface and services threads must have been joined).
 298  *
 299  * \param p_playlist the playlist object
 300  */
 301 void playlist_Destroy( playlist_t *p_playlist )
 302 {
 303     playlist_private_t *p_sys = pl_priv(p_playlist);
 304
 305     /* Remove all services discovery */
 306     playlist_ServicesDiscoveryKillAll( p_playlist );
 307
 308     msg_Dbg( p_playlist, "destroying" );
 309
 310     playlist_Deactivate( p_playlist );
 311
 312     /* Release input resources */
 313     assert( p_sys->p_input == NULL );
 314     input_resource_Release( p_sys->p_input_resource );
 315     if( p_sys->p_renderer )
 316         vlc_renderer_item_release( p_sys->p_renderer );
 317
 318     PL_LOCK;
 319     /* Release the current node */
 320     set_current_status_node( p_playlist, NULL );
 321     /* Release the current item */
 322     set_current_status_item( p_playlist, NULL );
 323
 324     /* Destroy arrays completely - faster than one item at a time */
 325     ARRAY_RESET( p_playlist->items );
 326     ARRAY_RESET( p_playlist->current );
 327
 328     /* Remove all remaining items */
 329     playlist_NodeDeleteExplicit( p_playlist, p_playlist->p_playing,
 330         PLAYLIST_DELETE_FORCE );
 331
 332     assert( p_playlist->root.i_children <= 0 );
 333     PL_UNLOCK;
 334
 335     vlc_cond_destroy( &p_sys->signal );
 336     vlc_mutex_destroy( &p_sys->lock );
 337
 338     vlc_http_cookie_jar_t *cookies = var_GetAddress( p_playlist, "http-cookies" );
 339     if ( cookies )
 340     {
 341         var_Destroy( p_playlist, "http-cookies" );
 342         vlc_http_cookies_destroy( cookies );
 343     }
 344
 345     vlc_object_release( p_playlist );
 346 }
 347
 348 /** Get current playing input.
 349  */
 350 input_thread_t *playlist_CurrentInputLocked( playlist_t *p_playlist )
 351 {
 352     PL_ASSERT_LOCKED;
 353
 354     input_thread_t *p_input = pl_priv(p_playlist)->p_input;
 355     if( p_input != NULL )
 356         vlc_object_hold( p_input );
 357     return p_input;
 358 }
 359
 360
 361 /** Get current playing input.
 362  */
 363 input_thread_t * playlist_CurrentInput( playlist_t * p_playlist )
 364 {
 365     input_thread_t * p_input;
 366     PL_LOCK;
 367     p_input = playlist_CurrentInputLocked( p_playlist );
 368     PL_UNLOCK;
 369     return p_input;
 370 }
 371
 372 /**
 373  * @}
 374  */
 375
 376 /** Accessor for status item and status nodes.
 377  */
 378 playlist_item_t * get_current_status_item( playlist_t * p_playlist )
 379 {
 380     PL_ASSERT_LOCKED;
 381
 382     return pl_priv(p_playlist)->status.p_item;
 383 }
 384
 385 playlist_item_t * get_current_status_node( playlist_t * p_playlist )
 386 {
 387     PL_ASSERT_LOCKED;
 388
 389     return pl_priv(p_playlist)->status.p_node;
 390 }
 391
 392 void set_current_status_item( playlist_t * p_playlist,
 393     playlist_item_t * p_item )
 394 {
 395     PL_ASSERT_LOCKED;
 396
 397     pl_priv(p_playlist)->status.p_item = p_item;
 398 }
 399
 400 void set_current_status_node( playlist_t * p_playlist,
 401     playlist_item_t * p_node )
 402 {
 403     PL_ASSERT_LOCKED;
 404
 405     pl_priv(p_playlist)->status.p_node = p_node;
 406 }
 407
 408 static void VariablesInit( playlist_t *p_playlist )
 409 {
 410     /* These variables control updates */
 411     var_Create( p_playlist, "item-change", VLC_VAR_ADDRESS );
 412     var_Create( p_playlist, "leaf-to-parent", VLC_VAR_INTEGER );
 413
 414     var_Create( p_playlist, "playlist-item-append", VLC_VAR_ADDRESS );
 415     var_Create( p_playlist, "playlist-item-deleted", VLC_VAR_ADDRESS );
 416
 417     var_Create( p_playlist, "input-current", VLC_VAR_ADDRESS );
 418
 419     /* Variables to control playback */
 420     var_Create( p_playlist, "playlist-autostart", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 421     var_Create( p_playlist, "random", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 422     var_AddCallback( p_playlist, "random", RandomCallback, NULL );
 423     var_Create( p_playlist, "repeat", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 424     var_Create( p_playlist, "loop", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 425     var_Create( p_playlist, "corks", VLC_VAR_INTEGER );
 426     var_AddCallback( p_playlist, "corks", CorksCallback, NULL );
 427
 428     var_Create( p_playlist, "rate", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
 429     var_AddCallback( p_playlist, "rate", RateCallback, NULL );
 430     var_Create( p_playlist, "rate-slower", VLC_VAR_VOID );
 431     var_AddCallback( p_playlist, "rate-slower", RateOffsetCallback, NULL );
 432     var_Create( p_playlist, "rate-faster", VLC_VAR_VOID );
 433     var_AddCallback( p_playlist, "rate-faster", RateOffsetCallback, NULL );
 434
 435     var_Create( p_playlist, "video-splitter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 436     var_AddCallback( p_playlist, "video-splitter", VideoSplitterCallback, NULL );
 437
 438     var_Create( p_playlist, "video-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 439     var_Create( p_playlist, "sub-source", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 440     var_Create( p_playlist, "sub-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 441
 442     /* sout variables */
 443     var_Create( p_playlist, "sout", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 444     var_Create( p_playlist, "demux-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 445
 446     /* */
 447     var_Create( p_playlist, "metadata-network-access", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 448
 449     /* Variables to preserve video output parameters */
 450     var_Create( p_playlist, "fullscreen", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 451     var_Create( p_playlist, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 452     var_Create( p_playlist, "video-wallpaper", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 453
 454     /* Audio output parameters */
 455     var_Create( p_playlist, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 456     var_Create( p_playlist, "audio-device", VLC_VAR_STRING );
 457     var_Create( p_playlist, "mute", VLC_VAR_BOOL );
 458     var_Create( p_playlist, "volume", VLC_VAR_FLOAT );
 459     var_SetFloat( p_playlist, "volume", -1.f );
 460
 461     var_Create( p_playlist, "sub-text-scale",
 462                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND );
 463
 464     /* Callbacks between interfaces */
 465
 466     /* Create a variable for showing the right click menu */
 467     var_Create( p_playlist, "intf-popupmenu", VLC_VAR_BOOL );
 468
 469     /* Create a variable for showing the fullscreen interface */
 470     var_Create( p_playlist, "intf-toggle-fscontrol", VLC_VAR_VOID );
 471
 472     /* Create a variable for the Boss Key */
 473     var_Create( p_playlist, "intf-boss", VLC_VAR_VOID );
 474
 475     /* Create a variable for showing the main interface */
 476     var_Create( p_playlist, "intf-show", VLC_VAR_VOID );
 477 }
 478
 479 playlist_item_t * playlist_CurrentPlayingItem( playlist_t * p_playlist )
 480 {
 481     PL_ASSERT_LOCKED;
 482
 483     return pl_priv(p_playlist)->status.p_item;
 484 }
 485
 486 int playlist_Status( playlist_t * p_playlist )
 487 {
 488     input_thread_t *p_input = pl_priv(p_playlist)->p_input;
 489
 490     PL_ASSERT_LOCKED;
 491
 492     if( p_input == NULL )
 493         return PLAYLIST_STOPPED;
 494     if( var_GetInteger( p_input, "state" ) == PAUSE_S )
 495         return PLAYLIST_PAUSED;
 496     return PLAYLIST_RUNNING;
 497 }
 498