src/input/resource.c

   1 /*****************************************************************************
   2  * resource.c
   3  *****************************************************************************
   4  * Copyright (C) 2008 Laurent Aimar
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar < fenrir _AT_ videolan _DOT_ 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 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <assert.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_vout.h>
  35 #include <vlc_spu.h>
  36 #include <vlc_aout.h>
  37 #include <vlc_sout.h>
  38 #include "../libvlc.h"
  39 #include "../stream_output/stream_output.h"
  40 #include "../audio_output/aout_internal.h"
  41 #include "../video_output/vout_control.h"
  42 #include "input_interface.h"
  43 #include "resource.h"
  44
  45 struct input_resource_t
  46 {
  47     VLC_GC_MEMBERS
  48
  49     vlc_object_t   *p_parent;
  50
  51     /* This lock is used to serialize request and protect
  52      * our variables */
  53     vlc_mutex_t    lock;
  54
  55     /* */
  56     input_thread_t *p_input;
  57
  58     sout_instance_t *p_sout;
  59     vout_thread_t   *p_vout_free;
  60
  61     /* This lock is used to protect vout resources access (for hold)
  62      * It is a special case because of embed video (possible deadlock
  63      * between vout window request and vout holds in some(qt4) interface)
  64      */
  65     vlc_mutex_t    lock_hold;
  66
  67     /* You need lock+lock_hold to write to the following variables and
  68      * only lock or lock_hold to read them */
  69
  70     int             i_vout;
  71     vout_thread_t   **pp_vout;
  72
  73     aout_instance_t *p_aout;
  74 };
  75
  76 /* */
  77 static void DestroySout( input_resource_t *p_resource )
  78 {
  79 #ifdef ENABLE_SOUT
  80     if( p_resource->p_sout )
  81         sout_DeleteInstance( p_resource->p_sout );
  82 #endif
  83     p_resource->p_sout = NULL;
  84 }
  85
  86 static sout_instance_t *RequestSout( input_resource_t *p_resource,
  87                                      sout_instance_t *p_sout, const char *psz_sout )
  88 {
  89 #ifdef ENABLE_SOUT
  90     if( !p_sout && !psz_sout )
  91     {
  92         if( p_resource->p_sout )
  93             msg_Dbg( p_resource->p_sout, "destroying useless sout" );
  94         DestroySout( p_resource );
  95         return NULL;
  96     }
  97
  98     assert( p_resource->p_input );
  99     assert( !p_sout || ( !p_resource->p_sout && !psz_sout ) );
 100
 101     /* Check the validity of the sout */
 102     if( p_resource->p_sout &&
 103         strcmp( p_resource->p_sout->psz_sout, psz_sout ) )
 104     {
 105         msg_Dbg( p_resource->p_parent, "destroying unusable sout" );
 106         DestroySout( p_resource );
 107     }
 108
 109     if( psz_sout )
 110     {
 111         if( p_resource->p_sout )
 112         {
 113             /* Reuse it */
 114             msg_Dbg( p_resource->p_parent, "reusing sout" );
 115             msg_Dbg( p_resource->p_parent, "you probably want to use gather stream_out" );
 116         }
 117         else
 118         {
 119             /* Create a new one */
 120             p_resource->p_sout = sout_NewInstance( p_resource->p_parent, psz_sout );
 121         }
 122
 123         p_sout = p_resource->p_sout;
 124         p_resource->p_sout = NULL;
 125
 126         return p_sout;
 127     }
 128     else
 129     {
 130         p_resource->p_sout = p_sout;
 131         return NULL;
 132     }
 133 #else
 134     return NULL;
 135 #endif
 136 }
 137
 138 /* */
 139 static void DestroyVout( input_resource_t *p_resource )
 140 {
 141     assert( p_resource->i_vout == 0 );
 142
 143     if( p_resource->p_vout_free )
 144         vout_CloseAndRelease( p_resource->p_vout_free );
 145
 146     p_resource->p_vout_free = NULL;
 147 }
 148
 149 static void DisplayVoutTitle( input_resource_t *p_resource,
 150                               vout_thread_t *p_vout )
 151 {
 152     assert( p_resource->p_input );
 153
 154     /* TODO display the title only one time for the same input ? */
 155
 156     input_item_t *p_item = input_GetItem( p_resource->p_input );
 157
 158     char *psz_nowplaying = input_item_GetNowPlaying( p_item );
 159     if( psz_nowplaying && *psz_nowplaying )
 160     {
 161         vout_DisplayTitle( p_vout, psz_nowplaying );
 162     }
 163     else
 164     {
 165         char *psz_artist = input_item_GetArtist( p_item );
 166         char *psz_name = input_item_GetTitle( p_item );
 167
 168         if( !psz_name || *psz_name == '\0' )
 169         {
 170             free( psz_name );
 171             psz_name = input_item_GetName( p_item );
 172         }
 173         if( psz_artist && *psz_artist )
 174         {
 175             char *psz_string;
 176             if( asprintf( &psz_string, "%s - %s", psz_name, psz_artist ) != -1 )
 177             {
 178                 vout_DisplayTitle( p_vout, psz_string );
 179                 free( psz_string );
 180             }
 181         }
 182         else if( psz_name )
 183         {
 184             vout_DisplayTitle( p_vout, psz_name );
 185         }
 186         free( psz_name );
 187         free( psz_artist );
 188     }
 189     free( psz_nowplaying );
 190 }
 191 static vout_thread_t *RequestVout( input_resource_t *p_resource,
 192                                    vout_thread_t *p_vout,
 193                                    video_format_t *p_fmt, unsigned dpb_size,
 194                                    bool b_recycle )
 195 {
 196     vlc_assert_locked( &p_resource->lock );
 197
 198     if( !p_vout && !p_fmt )
 199     {
 200         if( p_resource->p_vout_free )
 201         {
 202             msg_Dbg( p_resource->p_vout_free, "destroying useless vout" );
 203             vout_CloseAndRelease( p_resource->p_vout_free );
 204             p_resource->p_vout_free = NULL;
 205         }
 206         return NULL;
 207     }
 208
 209     assert( p_resource->p_input );
 210     if( p_fmt )
 211     {
 212         /* */
 213         if( !p_vout && p_resource->p_vout_free )
 214         {
 215             msg_Dbg( p_resource->p_parent, "trying to reuse free vout" );
 216             p_vout = p_resource->p_vout_free;
 217
 218             p_resource->p_vout_free = NULL;
 219         }
 220         else if( p_vout )
 221         {
 222             assert( p_vout != p_resource->p_vout_free );
 223
 224             vlc_mutex_lock( &p_resource->lock_hold );
 225             TAB_REMOVE( p_resource->i_vout, p_resource->pp_vout, p_vout );
 226             vlc_mutex_unlock( &p_resource->lock_hold );
 227         }
 228
 229         /* */
 230         vout_configuration_t cfg = {
 231             .vout       = p_vout,
 232             .input      = VLC_OBJECT(p_resource->p_input),
 233             .change_fmt = true,
 234             .fmt        = p_fmt,
 235             .dpb_size   = dpb_size,
 236         };
 237         p_vout = vout_Request( p_resource->p_parent, &cfg );
 238         if( !p_vout )
 239             return NULL;
 240
 241         DisplayVoutTitle( p_resource, p_vout );
 242
 243         vlc_mutex_lock( &p_resource->lock_hold );
 244         TAB_APPEND( p_resource->i_vout, p_resource->pp_vout, p_vout );
 245         vlc_mutex_unlock( &p_resource->lock_hold );
 246
 247         return p_vout;
 248     }
 249     else
 250     {
 251         assert( p_vout );
 252
 253         vlc_mutex_lock( &p_resource->lock_hold );
 254         TAB_REMOVE( p_resource->i_vout, p_resource->pp_vout, p_vout );
 255         const int i_vout_active = p_resource->i_vout;
 256         vlc_mutex_unlock( &p_resource->lock_hold );
 257
 258         if( p_resource->p_vout_free || i_vout_active > 0 || !b_recycle )
 259         {
 260             if( b_recycle )
 261                 msg_Dbg( p_resource->p_parent, "detroying vout (already one saved or active)" );
 262             vout_CloseAndRelease( p_vout );
 263         }
 264         else
 265         {
 266             msg_Dbg( p_resource->p_parent, "saving a free vout" );
 267             vout_Flush( p_vout, 1 );
 268             vout_FlushSubpictureChannel( p_vout, -1 );
 269
 270             vout_configuration_t cfg = {
 271                 .vout       = p_vout,
 272                 .input      = NULL,
 273                 .change_fmt = false,
 274                 .fmt        = NULL,
 275                 .dpb_size   = 0,
 276             };
 277             p_resource->p_vout_free = vout_Request( p_resource->p_parent, &cfg );
 278         }
 279         return NULL;
 280     }
 281 }
 282 static vout_thread_t *HoldVout( input_resource_t *p_resource )
 283 {
 284     /* TODO FIXME: p_resource->pp_vout order is NOT stable */
 285     vlc_mutex_lock( &p_resource->lock_hold );
 286
 287     vout_thread_t *p_vout = p_resource->i_vout > 0 ? p_resource->pp_vout[0] : NULL;
 288     if( p_vout )
 289         vlc_object_hold( p_vout );
 290
 291     vlc_mutex_unlock( &p_resource->lock_hold );
 292
 293     return p_vout;
 294 }
 295
 296 static void HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout,
 297                        size_t *pi_vout )
 298 {
 299     vout_thread_t **pp_vout;
 300
 301     *pi_vout = 0;
 302     *ppp_vout = NULL;
 303
 304     vlc_mutex_lock( &p_resource->lock_hold );
 305
 306     if( p_resource->i_vout <= 0 )
 307         goto exit;
 308
 309     pp_vout = malloc( p_resource->i_vout * sizeof(*pp_vout) );
 310     if( !pp_vout )
 311         goto exit;
 312
 313     *ppp_vout = pp_vout;
 314     *pi_vout = p_resource->i_vout;
 315
 316     for( int i = 0; i < p_resource->i_vout; i++ )
 317     {
 318         pp_vout[i] = p_resource->pp_vout[i];
 319         vlc_object_hold( pp_vout[i] );
 320     }
 321
 322 exit:
 323     vlc_mutex_unlock( &p_resource->lock_hold );
 324 }
 325
 326 /* */
 327 static void DestroyAout( input_resource_t *p_resource )
 328 {
 329     if( p_resource->p_aout )
 330         vlc_object_release( p_resource->p_aout );
 331     p_resource->p_aout = NULL;
 332 }
 333 static aout_instance_t *RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
 334 {
 335     vlc_assert_locked( &p_resource->lock );
 336     assert( p_resource->p_input );
 337
 338     if( p_aout )
 339     {
 340         msg_Dbg( p_resource->p_parent, "releasing aout" );
 341         vlc_object_release( p_aout );
 342         return NULL;
 343     }
 344     else
 345     {
 346         p_aout = p_resource->p_aout;
 347         if( !p_aout )
 348         {
 349             msg_Dbg( p_resource->p_parent, "creating aout" );
 350             p_aout = aout_New( p_resource->p_parent );
 351
 352             vlc_mutex_lock( &p_resource->lock_hold );
 353             p_resource->p_aout = p_aout;
 354             vlc_mutex_unlock( &p_resource->lock_hold );
 355         }
 356         else
 357         {
 358             msg_Dbg( p_resource->p_parent, "reusing aout" );
 359         }
 360
 361         if( !p_aout )
 362             return NULL;
 363         vlc_object_hold( p_aout );
 364         return p_aout;
 365     }
 366 }
 367 static aout_instance_t *HoldAout( input_resource_t *p_resource )
 368 {
 369     vlc_mutex_lock( &p_resource->lock_hold );
 370
 371     aout_instance_t *p_aout = p_resource->p_aout;
 372     if( p_aout )
 373         vlc_object_hold( p_aout );
 374
 375     vlc_mutex_unlock( &p_resource->lock_hold );
 376
 377     return p_aout;
 378 }
 379 static void TerminateAout( input_resource_t *p_resource )
 380 {
 381     vlc_mutex_lock( &p_resource->lock_hold );
 382
 383     aout_instance_t *p_aout = p_resource->p_aout;
 384     p_resource->p_aout = NULL;
 385
 386     vlc_mutex_unlock( &p_resource->lock_hold );
 387
 388     if( p_aout )
 389         vlc_object_release( p_aout );
 390 }
 391
 392 static void Destructor( gc_object_t *p_gc )
 393 {
 394     input_resource_t *p_resource = vlc_priv( p_gc, input_resource_t );
 395
 396     DestroySout( p_resource );
 397     DestroyVout( p_resource );
 398     DestroyAout( p_resource );
 399
 400     vlc_mutex_destroy( &p_resource->lock_hold );
 401     vlc_mutex_destroy( &p_resource->lock );
 402     free( p_resource );
 403 }
 404
 405 /* */
 406 input_resource_t *input_resource_New( vlc_object_t *p_parent )
 407 {
 408     input_resource_t *p_resource = calloc( 1, sizeof(*p_resource) );
 409     if( !p_resource )
 410         return NULL;
 411
 412     vlc_gc_init( p_resource, Destructor );
 413     p_resource->p_parent = p_parent;
 414     vlc_mutex_init( &p_resource->lock );
 415     vlc_mutex_init( &p_resource->lock_hold );
 416     return p_resource;
 417 }
 418
 419 void input_resource_Release( input_resource_t *p_resource )
 420 {
 421     vlc_gc_decref( p_resource );
 422 }
 423
 424 input_resource_t *input_resource_Hold( input_resource_t *p_resource )
 425 {
 426     vlc_gc_incref( p_resource );
 427     return p_resource;
 428 }
 429
 430 void input_resource_SetInput( input_resource_t *p_resource, input_thread_t *p_input )
 431 {
 432     vlc_mutex_lock( &p_resource->lock );
 433
 434     if( p_resource->p_input && !p_input )
 435         assert( p_resource->i_vout == 0 );
 436
 437     /* */
 438     p_resource->p_input = p_input;
 439
 440     vlc_mutex_unlock( &p_resource->lock );
 441 }
 442
 443 vout_thread_t *input_resource_RequestVout( input_resource_t *p_resource,
 444                                             vout_thread_t *p_vout,
 445                                             video_format_t *p_fmt, unsigned dpb_size,
 446                                             bool b_recycle )
 447 {
 448     vlc_mutex_lock( &p_resource->lock );
 449     vout_thread_t *p_ret = RequestVout( p_resource, p_vout, p_fmt, dpb_size, b_recycle );
 450     vlc_mutex_unlock( &p_resource->lock );
 451
 452     return p_ret;
 453 }
 454 vout_thread_t *input_resource_HoldVout( input_resource_t *p_resource )
 455 {
 456     return HoldVout( p_resource );
 457 }
 458
 459 void input_resource_HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout,
 460                                size_t *pi_vout )
 461 {
 462     HoldVouts( p_resource, ppp_vout, pi_vout );
 463 }
 464
 465 void input_resource_TerminateVout( input_resource_t *p_resource )
 466 {
 467     input_resource_RequestVout( p_resource, NULL, NULL, 0, false );
 468 }
 469 bool input_resource_HasVout( input_resource_t *p_resource )
 470 {
 471     vlc_mutex_lock( &p_resource->lock );
 472     assert( !p_resource->p_input );
 473     const bool b_vout = p_resource->p_vout_free != NULL;
 474     vlc_mutex_unlock( &p_resource->lock );
 475
 476     return b_vout;
 477 }
 478
 479 /* */
 480 aout_instance_t *input_resource_RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
 481 {
 482     vlc_mutex_lock( &p_resource->lock );
 483     aout_instance_t *p_ret = RequestAout( p_resource, p_aout );
 484     vlc_mutex_unlock( &p_resource->lock );
 485
 486     return p_ret;
 487 }
 488 aout_instance_t *input_resource_HoldAout( input_resource_t *p_resource )
 489 {
 490     return HoldAout( p_resource );
 491 }
 492
 493 /* */
 494 sout_instance_t *input_resource_RequestSout( input_resource_t *p_resource, sout_instance_t *p_sout, const char *psz_sout )
 495 {
 496     vlc_mutex_lock( &p_resource->lock );
 497     sout_instance_t *p_ret = RequestSout( p_resource, p_sout, psz_sout );
 498     vlc_mutex_unlock( &p_resource->lock );
 499
 500     return p_ret;
 501 }
 502 void input_resource_TerminateSout( input_resource_t *p_resource )
 503 {
 504     input_resource_RequestSout( p_resource, NULL, NULL );
 505 }
 506
 507 void input_resource_Terminate( input_resource_t *p_resource )
 508 {
 509     input_resource_TerminateSout( p_resource );
 510
 511     vlc_mutex_lock( &p_resource->lock );
 512     TerminateAout( p_resource );
 513     vlc_mutex_unlock( &p_resource->lock );
 514
 515     input_resource_TerminateVout( p_resource );
 516 }
 517