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