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             .fmt      = p_fmt,
 250             .dpb_size = dpb_size,
 251         };
 252         p_vout = vout_Request( p_resource->p_input, &cfg );
 253         if( !p_vout )
 254             return NULL;
 255
 256         DisplayVoutTitle( p_resource, p_vout );
 257
 258         vlc_mutex_lock( &p_resource->lock_hold );
 259         TAB_APPEND( p_resource->i_vout, p_resource->pp_vout, p_vout );
 260         vlc_mutex_unlock( &p_resource->lock_hold );
 261
 262         return p_vout;
 263     }
 264     else
 265     {
 266         assert( p_vout );
 267
 268         vlc_mutex_lock( &p_resource->lock_hold );
 269         TAB_REMOVE( p_resource->i_vout, p_resource->pp_vout, p_vout );
 270         const int i_vout_active = p_resource->i_vout;
 271         vlc_mutex_unlock( &p_resource->lock_hold );
 272
 273         if( p_resource->p_vout_free || i_vout_active > 0 || !b_recycle )
 274         {
 275             if( b_recycle )
 276                 msg_Dbg( p_resource->p_input, "detroying vout (already one saved or active)" );
 277             vout_CloseAndRelease( p_vout );
 278         }
 279         else
 280         {
 281             msg_Dbg( p_resource->p_input, "saving a free vout" );
 282             vout_Flush( p_vout, 1 );
 283             vout_FlushSubpictureChannel( p_vout, -1 );
 284
 285             vout_configuration_t cfg = {
 286                 .vout     = p_vout,
 287                 .input    = NULL,
 288                 .fmt      = p_fmt,
 289                 .dpb_size = 0,
 290             };
 291             p_resource->p_vout_free = vout_Request( p_resource->p_input, &cfg );
 292         }
 293         return NULL;
 294     }
 295 }
 296 static vout_thread_t *HoldVout( input_resource_t *p_resource )
 297 {
 298     /* TODO FIXME: p_resource->pp_vout order is NOT stable */
 299     vlc_mutex_lock( &p_resource->lock_hold );
 300
 301     vout_thread_t *p_vout = p_resource->i_vout > 0 ? p_resource->pp_vout[0] : NULL;
 302     if( p_vout )
 303         vlc_object_hold( p_vout );
 304
 305     vlc_mutex_unlock( &p_resource->lock_hold );
 306
 307     return p_vout;
 308 }
 309
 310 static void HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout,
 311                        size_t *pi_vout )
 312 {
 313     vout_thread_t **pp_vout;
 314
 315     *pi_vout = 0;
 316     *ppp_vout = NULL;
 317
 318     vlc_mutex_lock( &p_resource->lock_hold );
 319
 320     if( p_resource->i_vout <= 0 )
 321         goto exit;
 322
 323     pp_vout = malloc( p_resource->i_vout * sizeof(*pp_vout) );
 324     if( !pp_vout )
 325         goto exit;
 326
 327     *ppp_vout = pp_vout;
 328     *pi_vout = p_resource->i_vout;
 329
 330     for( int i = 0; i < p_resource->i_vout; i++ )
 331     {
 332         pp_vout[i] = p_resource->pp_vout[i];
 333         vlc_object_hold( pp_vout[i] );
 334     }
 335
 336 exit:
 337     vlc_mutex_unlock( &p_resource->lock_hold );
 338 }
 339
 340 /* */
 341 static void DestroyAout( input_resource_t *p_resource )
 342 {
 343     if( p_resource->p_aout )
 344         vlc_object_release( p_resource->p_aout );
 345     p_resource->p_aout = NULL;
 346 }
 347 static aout_instance_t *DetachAout( input_resource_t *p_resource )
 348 {
 349     vlc_assert_locked( &p_resource->lock );
 350     vlc_mutex_lock( &p_resource->lock_hold );
 351
 352     aout_instance_t *p_aout = p_resource->p_aout;
 353     p_resource->p_aout = NULL;
 354
 355     vlc_mutex_unlock( &p_resource->lock_hold );
 356
 357     return p_aout;
 358 }
 359
 360 static aout_instance_t *RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
 361 {
 362     vlc_assert_locked( &p_resource->lock );
 363     assert( p_resource->p_input );
 364
 365     if( p_aout )
 366     {
 367         msg_Dbg( p_resource->p_input, "releasing aout" );
 368         vlc_object_release( p_aout );
 369         return NULL;
 370     }
 371     else
 372     {
 373         p_aout = p_resource->p_aout;
 374         if( !p_aout )
 375         {
 376             msg_Dbg( p_resource->p_input, "creating aout" );
 377             p_aout = aout_New( p_resource->p_input );
 378
 379             vlc_mutex_lock( &p_resource->lock_hold );
 380             p_resource->p_aout = p_aout;
 381             vlc_mutex_unlock( &p_resource->lock_hold );
 382         }
 383         else
 384         {
 385             msg_Dbg( p_resource->p_input, "reusing aout" );
 386         }
 387
 388         if( !p_aout )
 389             return NULL;
 390
 391         vlc_object_detach( p_aout );
 392         vlc_object_attach( p_aout, p_resource->p_input );
 393         vlc_object_hold( p_aout );
 394         return p_aout;
 395     }
 396 }
 397 static aout_instance_t *HoldAout( input_resource_t *p_resource )
 398 {
 399     vlc_mutex_lock( &p_resource->lock_hold );
 400
 401     aout_instance_t *p_aout = p_resource->p_aout;
 402     if( p_aout )
 403         vlc_object_hold( p_aout );
 404
 405     vlc_mutex_unlock( &p_resource->lock_hold );
 406
 407     return p_aout;
 408 }
 409
 410 /* */
 411 input_resource_t *input_resource_New( void )
 412 {
 413     input_resource_t *p_resource = calloc( 1, sizeof(*p_resource) );
 414     if( !p_resource )
 415         return NULL;
 416
 417     vlc_mutex_init( &p_resource->lock );
 418     vlc_mutex_init( &p_resource->lock_hold );
 419     return p_resource;
 420 }
 421
 422 void input_resource_Delete( input_resource_t *p_resource )
 423 {
 424     DestroySout( p_resource );
 425     DestroyVout( p_resource );
 426     DestroyAout( p_resource );
 427
 428     vlc_mutex_destroy( &p_resource->lock_hold );
 429     vlc_mutex_destroy( &p_resource->lock );
 430     free( p_resource );
 431 }
 432
 433 void input_resource_SetInput( input_resource_t *p_resource, input_thread_t *p_input )
 434 {
 435     vlc_mutex_lock( &p_resource->lock );
 436
 437     if( p_resource->p_input && !p_input )
 438     {
 439         if( p_resource->p_aout )
 440             vlc_object_detach( p_resource->p_aout );
 441
 442         assert( p_resource->i_vout == 0 );
 443         if( p_resource->p_vout_free )
 444             vlc_object_detach( p_resource->p_vout_free );
 445
 446         if( p_resource->p_sout )
 447             vlc_object_detach( p_resource->p_sout );
 448     }
 449
 450     /* */
 451     p_resource->p_input = p_input;
 452
 453     vlc_mutex_unlock( &p_resource->lock );
 454 }
 455
 456 input_resource_t *input_resource_Detach( input_resource_t *p_resource )
 457 {
 458     input_resource_t *p_ret = input_resource_New();
 459     if( !p_ret )
 460         return NULL;
 461
 462     vlc_mutex_lock( &p_resource->lock );
 463     assert( !p_resource->p_input );
 464     p_ret->p_sout = DetachSout( p_resource );
 465     p_ret->p_vout_free = DetachVout( p_resource );
 466     p_ret->p_aout = DetachAout( p_resource );
 467     vlc_mutex_unlock( &p_resource->lock );
 468
 469     return p_ret;
 470 }
 471
 472 vout_thread_t *input_resource_RequestVout( input_resource_t *p_resource,
 473                                             vout_thread_t *p_vout,
 474                                             video_format_t *p_fmt, unsigned dpb_size,
 475                                             bool b_recycle )
 476 {
 477     vlc_mutex_lock( &p_resource->lock );
 478     vout_thread_t *p_ret = RequestVout( p_resource, p_vout, p_fmt, dpb_size, b_recycle );
 479     vlc_mutex_unlock( &p_resource->lock );
 480
 481     return p_ret;
 482 }
 483 vout_thread_t *input_resource_HoldVout( input_resource_t *p_resource )
 484 {
 485     return HoldVout( p_resource );
 486 }
 487
 488 void input_resource_HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout,
 489                                size_t *pi_vout )
 490 {
 491     HoldVouts( p_resource, ppp_vout, pi_vout );
 492 }
 493
 494 void input_resource_TerminateVout( input_resource_t *p_resource )
 495 {
 496     input_resource_RequestVout( p_resource, NULL, NULL, 0, false );
 497 }
 498 bool input_resource_HasVout( input_resource_t *p_resource )
 499 {
 500     vlc_mutex_lock( &p_resource->lock );
 501     assert( !p_resource->p_input );
 502     const bool b_vout = p_resource->p_vout_free != NULL;
 503     vlc_mutex_unlock( &p_resource->lock );
 504
 505     return b_vout;
 506 }
 507
 508 /* */
 509 aout_instance_t *input_resource_RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
 510 {
 511     vlc_mutex_lock( &p_resource->lock );
 512     aout_instance_t *p_ret = RequestAout( p_resource, p_aout );
 513     vlc_mutex_unlock( &p_resource->lock );
 514
 515     return p_ret;
 516 }
 517 aout_instance_t *input_resource_HoldAout( input_resource_t *p_resource )
 518 {
 519     return HoldAout( p_resource );
 520 }
 521 /* */
 522 sout_instance_t *input_resource_RequestSout( input_resource_t *p_resource, sout_instance_t *p_sout, const char *psz_sout )
 523 {
 524     vlc_mutex_lock( &p_resource->lock );
 525     sout_instance_t *p_ret = RequestSout( p_resource, p_sout, psz_sout );
 526     vlc_mutex_unlock( &p_resource->lock );
 527
 528     return p_ret;
 529 }
 530 void input_resource_TerminateSout( input_resource_t *p_resource )
 531 {
 532     input_resource_RequestSout( p_resource, NULL, NULL );
 533 }
 534