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