src/input/resource.c

   1 /*****************************************************************************
   2  * resource.c
   3  *****************************************************************************
   4  * Copyright (C) 2008 Laurent Aimar
   5  *
   6  * Authors: Laurent Aimar < fenrir _AT_ videolan _DOT_ org >
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <assert.h>
  31
  32 #include <vlc_common.h>
  33 #include <vlc_atomic.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_internal.h"
  42 #include "input_interface.h"
  43 #include "event.h"
  44 #include "resource.h"
  45
  46 struct input_resource_t
  47 {
  48     vlc_atomic_rc_t rc;
  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(qt) 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     bool            b_aout_busy;
  75     audio_output_t *p_aout;
  76 };
  77
  78 /* */
  79 static void DestroySout( input_resource_t *p_resource )
  80 {
  81 #ifdef ENABLE_SOUT
  82     if( p_resource->p_sout )
  83         sout_DeleteInstance( p_resource->p_sout );
  84 #endif
  85     p_resource->p_sout = NULL;
  86 }
  87
  88 static sout_instance_t *RequestSout( input_resource_t *p_resource,
  89                                      sout_instance_t *p_sout, const char *psz_sout )
  90 {
  91 #ifdef ENABLE_SOUT
  92     if( !p_sout && !psz_sout )
  93     {
  94         if( p_resource->p_sout )
  95         {
  96             msg_Dbg( p_resource->p_sout, "destroying useless sout" );
  97             DestroySout( p_resource );
  98         }
  99         return NULL;
 100     }
 101
 102     assert( !p_sout || ( !p_resource->p_sout && !psz_sout ) );
 103
 104     /* Check the validity of the sout */
 105     if( p_resource->p_sout &&
 106         strcmp( p_resource->p_sout->psz_sout, psz_sout ) )
 107     {
 108         msg_Dbg( p_resource->p_parent, "destroying unusable sout" );
 109         DestroySout( p_resource );
 110     }
 111
 112     if( psz_sout )
 113     {
 114         if( p_resource->p_sout )
 115         {
 116             /* Reuse it */
 117             msg_Dbg( p_resource->p_parent, "reusing sout" );
 118             msg_Dbg( p_resource->p_parent, "you probably want to use gather stream_out" );
 119         }
 120         else
 121         {
 122             /* Create a new one */
 123             p_resource->p_sout = sout_NewInstance( p_resource->p_parent, psz_sout );
 124         }
 125
 126         p_sout = p_resource->p_sout;
 127         p_resource->p_sout = NULL;
 128
 129         return p_sout;
 130     }
 131     else
 132     {
 133         p_resource->p_sout = p_sout;
 134         return NULL;
 135     }
 136 #else
 137     VLC_UNUSED (p_resource); VLC_UNUSED (p_sout); VLC_UNUSED (psz_sout);
 138     return NULL;
 139 #endif
 140 }
 141
 142 /* */
 143 static void DestroyVout( input_resource_t *p_resource )
 144 {
 145     assert( p_resource->i_vout == 0 );
 146
 147     if( p_resource->p_vout_free )
 148         vout_Close( p_resource->p_vout_free );
 149
 150     p_resource->p_vout_free = NULL;
 151 }
 152
 153 static void DisplayVoutTitle( input_resource_t *p_resource,
 154                               vout_thread_t *p_vout )
 155 {
 156     if( p_resource->p_input == NULL )
 157         return;
 158
 159     /* TODO display the title only one time for the same input ? */
 160
 161     input_item_t *p_item = input_GetItem( p_resource->p_input );
 162
 163     char *psz_nowplaying = input_item_GetNowPlayingFb( p_item );
 164     if( psz_nowplaying && *psz_nowplaying )
 165     {
 166         vout_DisplayTitle( p_vout, psz_nowplaying );
 167     }
 168     else
 169     {
 170         char *psz_artist = input_item_GetArtist( p_item );
 171         char *psz_name = input_item_GetTitle( p_item );
 172
 173         if( !psz_name || *psz_name == '\0' )
 174         {
 175             free( psz_name );
 176             psz_name = input_item_GetName( p_item );
 177         }
 178         if( psz_artist && *psz_artist )
 179         {
 180             char *psz_string;
 181             if( asprintf( &psz_string, "%s - %s", psz_name, psz_artist ) != -1 )
 182             {
 183                 vout_DisplayTitle( p_vout, psz_string );
 184                 free( psz_string );
 185             }
 186         }
 187         else if( psz_name )
 188         {
 189             vout_DisplayTitle( p_vout, psz_name );
 190         }
 191         free( psz_name );
 192         free( psz_artist );
 193     }
 194     free( psz_nowplaying );
 195 }
 196
 197 static vout_thread_t *HoldVout( input_resource_t *p_resource )
 198 {
 199     /* TODO FIXME: p_resource->pp_vout order is NOT stable */
 200     vlc_mutex_lock( &p_resource->lock_hold );
 201
 202     vout_thread_t *p_vout = p_resource->i_vout > 0 ? p_resource->pp_vout[0] : NULL;
 203     if( p_vout )
 204         vlc_object_hold( p_vout );
 205
 206     vlc_mutex_unlock( &p_resource->lock_hold );
 207
 208     return p_vout;
 209 }
 210
 211 static void HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout,
 212                        size_t *pi_vout )
 213 {
 214     vout_thread_t **pp_vout;
 215
 216     *pi_vout = 0;
 217     *ppp_vout = NULL;
 218
 219     vlc_mutex_lock( &p_resource->lock_hold );
 220
 221     if( p_resource->i_vout <= 0 )
 222         goto exit;
 223
 224     pp_vout = vlc_alloc( p_resource->i_vout, sizeof(*pp_vout) );
 225     if( !pp_vout )
 226         goto exit;
 227
 228     *ppp_vout = pp_vout;
 229     *pi_vout = p_resource->i_vout;
 230
 231     for( int i = 0; i < p_resource->i_vout; i++ )
 232     {
 233         pp_vout[i] = p_resource->pp_vout[i];
 234         vlc_object_hold( pp_vout[i] );
 235     }
 236
 237 exit:
 238     vlc_mutex_unlock( &p_resource->lock_hold );
 239 }
 240
 241 /* Audio output */
 242 audio_output_t *input_resource_GetAout( input_resource_t *p_resource )
 243 {
 244     audio_output_t *p_aout;
 245
 246     vlc_mutex_lock( &p_resource->lock_hold );
 247     p_aout = p_resource->p_aout;
 248
 249     if( p_aout == NULL || p_resource->b_aout_busy )
 250     {
 251         msg_Dbg( p_resource->p_parent, "creating audio output" );
 252         vlc_mutex_unlock( &p_resource->lock_hold );
 253
 254         p_aout = aout_New( p_resource->p_parent );
 255         if( p_aout == NULL )
 256             return NULL; /* failed */
 257
 258         vlc_mutex_lock( &p_resource->lock_hold );
 259         if( p_resource->p_aout == NULL )
 260             p_resource->p_aout = p_aout;
 261     }
 262     else
 263         msg_Dbg( p_resource->p_parent, "reusing audio output" );
 264
 265     if( p_resource->p_aout == p_aout )
 266     {
 267         assert( !p_resource->b_aout_busy );
 268         p_resource->b_aout_busy = true;
 269     }
 270     vlc_mutex_unlock( &p_resource->lock_hold );
 271     return p_aout;
 272 }
 273
 274 void input_resource_PutAout( input_resource_t *p_resource,
 275                              audio_output_t *p_aout )
 276 {
 277     assert( p_aout != NULL );
 278
 279     vlc_mutex_lock( &p_resource->lock_hold );
 280     if( p_aout == p_resource->p_aout )
 281     {
 282         assert( p_resource->b_aout_busy );
 283         p_resource->b_aout_busy = false;
 284         msg_Dbg( p_resource->p_parent, "keeping audio output" );
 285         p_aout = NULL;
 286     }
 287     else
 288         msg_Dbg( p_resource->p_parent, "destroying extra audio output" );
 289     vlc_mutex_unlock( &p_resource->lock_hold );
 290
 291     if( p_aout != NULL )
 292         aout_Destroy( p_aout );
 293 }
 294
 295 audio_output_t *input_resource_HoldAout( input_resource_t *p_resource )
 296 {
 297     audio_output_t *p_aout;
 298
 299     vlc_mutex_lock( &p_resource->lock_hold );
 300     p_aout = p_resource->p_aout;
 301     if( p_aout != NULL )
 302         vlc_object_hold( p_aout );
 303     vlc_mutex_unlock( &p_resource->lock_hold );
 304
 305     return p_aout;
 306 }
 307
 308 void input_resource_ResetAout( input_resource_t *p_resource )
 309 {
 310     audio_output_t *p_aout = NULL;
 311
 312     vlc_mutex_lock( &p_resource->lock_hold );
 313     if( !p_resource->b_aout_busy )
 314         p_aout = p_resource->p_aout;
 315
 316     p_resource->p_aout = NULL;
 317     p_resource->b_aout_busy = false;
 318     vlc_mutex_unlock( &p_resource->lock_hold );
 319
 320     if( p_aout != NULL )
 321         aout_Destroy( p_aout );
 322 }
 323
 324 /* Common */
 325 input_resource_t *input_resource_New( vlc_object_t *p_parent )
 326 {
 327     input_resource_t *p_resource = calloc( 1, sizeof(*p_resource) );
 328     if( !p_resource )
 329         return NULL;
 330
 331     vlc_atomic_rc_init( &p_resource->rc );
 332     p_resource->p_parent = p_parent;
 333     vlc_mutex_init( &p_resource->lock );
 334     vlc_mutex_init( &p_resource->lock_hold );
 335     return p_resource;
 336 }
 337
 338 void input_resource_Release( input_resource_t *p_resource )
 339 {
 340     if( !vlc_atomic_rc_dec( &p_resource->rc ) )
 341         return;
 342
 343     DestroySout( p_resource );
 344     DestroyVout( p_resource );
 345     if( p_resource->p_aout != NULL )
 346         aout_Destroy( p_resource->p_aout );
 347
 348     vlc_mutex_destroy( &p_resource->lock_hold );
 349     vlc_mutex_destroy( &p_resource->lock );
 350     free( p_resource );
 351 }
 352
 353 input_resource_t *input_resource_Hold( input_resource_t *p_resource )
 354 {
 355     vlc_atomic_rc_inc( &p_resource->rc );
 356     return p_resource;
 357 }
 358
 359 void input_resource_SetInput( input_resource_t *p_resource, input_thread_t *p_input )
 360 {
 361     vlc_mutex_lock( &p_resource->lock );
 362
 363     if( p_resource->p_input && !p_input )
 364         assert( p_resource->i_vout == 0 );
 365
 366     /* */
 367     p_resource->p_input = p_input;
 368
 369     vlc_mutex_unlock( &p_resource->lock );
 370 }
 371
 372 vout_thread_t *input_resource_GetVout(input_resource_t *p_resource,
 373                                       const vout_configuration_t *cfg)
 374 {
 375     vout_configuration_t cfg_buf;
 376     vout_thread_t *vout;
 377
 378     assert(cfg != NULL);
 379     assert(cfg->fmt != NULL);
 380     vlc_mutex_lock( &p_resource->lock );
 381
 382     if (cfg->vout == NULL && p_resource->p_vout_free != NULL) {
 383         msg_Dbg(p_resource->p_parent, "trying to reuse free vout");
 384
 385         cfg_buf = *cfg;
 386         cfg_buf.vout = p_resource->p_vout_free;
 387         p_resource->p_vout_free = NULL;
 388         cfg = &cfg_buf;
 389
 390     }  else if (cfg->vout != NULL) {
 391         assert(cfg->vout != p_resource->p_vout_free);
 392
 393         vlc_mutex_lock(&p_resource->lock_hold);
 394         TAB_REMOVE(p_resource->i_vout, p_resource->pp_vout, cfg->vout);
 395         vlc_mutex_unlock(&p_resource->lock_hold);
 396     }
 397
 398     vout = vout_Request(p_resource->p_parent, cfg, p_resource->p_input);
 399     if (vout != NULL) {
 400         DisplayVoutTitle(p_resource, vout);
 401
 402         /* Send original viewpoint to the input in order to update other ESes */
 403         if (p_resource->p_input != NULL)
 404             input_Control(p_resource->p_input, INPUT_SET_INITIAL_VIEWPOINT,
 405                           &cfg->fmt->pose);
 406
 407         vlc_mutex_lock(&p_resource->lock_hold);
 408         TAB_APPEND(p_resource->i_vout, p_resource->pp_vout, vout);
 409         vlc_mutex_unlock(&p_resource->lock_hold);
 410
 411         if (p_resource->p_input != NULL)
 412             input_SendEventVout(p_resource->p_input,
 413                 &(struct vlc_input_event_vout) {
 414                     .action = VLC_INPUT_EVENT_VOUT_ADDED,
 415                     .vout = vout,
 416                 });
 417     }
 418     vlc_mutex_unlock( &p_resource->lock );
 419     return vout;
 420 }
 421
 422 void input_resource_PutVout(input_resource_t *p_resource,
 423                             vout_thread_t *vout)
 424 {
 425     assert(vout != NULL);
 426     vlc_mutex_lock( &p_resource->lock );
 427
 428     vlc_mutex_lock(&p_resource->lock_hold);
 429     TAB_REMOVE(p_resource->i_vout, p_resource->pp_vout, vout);
 430
 431     const int active_vouts = p_resource->i_vout;
 432     vlc_mutex_unlock(&p_resource->lock_hold);
 433
 434     if (p_resource->p_input != NULL)
 435         input_SendEventVout(p_resource->p_input,
 436             &(struct vlc_input_event_vout) {
 437                 .action = VLC_INPUT_EVENT_VOUT_DELETED,
 438                 .vout = vout,
 439             });
 440
 441     if (p_resource->p_vout_free != NULL || active_vouts > 0) {
 442         msg_Dbg(p_resource->p_parent, "destroying vout (already one saved or active)");
 443         vout_Close(vout);
 444     } else {
 445         msg_Dbg(p_resource->p_parent, "saving a free vout");
 446         vout_FlushAll(vout);
 447         vout_FlushSubpictureChannel(vout, -1);
 448         vout_Stop(vout);
 449         p_resource->p_vout_free = vout;
 450     }
 451     vlc_mutex_unlock( &p_resource->lock );
 452 }
 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     vlc_mutex_lock(&p_resource->lock);
 468     if (p_resource->p_vout_free != NULL)
 469     {
 470         msg_Dbg(p_resource->p_vout_free, "destroying useless vout");
 471         vout_Close(p_resource->p_vout_free);
 472         p_resource->p_vout_free = NULL;
 473     }
 474     vlc_mutex_unlock(&p_resource->lock);
 475 }
 476
 477 bool input_resource_HasVout( input_resource_t *p_resource )
 478 {
 479     vlc_mutex_lock( &p_resource->lock );
 480     assert( !p_resource->p_input );
 481     const bool b_vout = p_resource->p_vout_free != NULL;
 482     vlc_mutex_unlock( &p_resource->lock );
 483
 484     return b_vout;
 485 }
 486
 487 /* */
 488 sout_instance_t *input_resource_RequestSout( input_resource_t *p_resource, sout_instance_t *p_sout, const char *psz_sout )
 489 {
 490     vlc_mutex_lock( &p_resource->lock );
 491     sout_instance_t *p_ret = RequestSout( p_resource, p_sout, psz_sout );
 492     vlc_mutex_unlock( &p_resource->lock );
 493
 494     return p_ret;
 495 }
 496 void input_resource_TerminateSout( input_resource_t *p_resource )
 497 {
 498     input_resource_RequestSout( p_resource, NULL, NULL );
 499 }
 500
 501 void input_resource_Terminate( input_resource_t *p_resource )
 502 {
 503     input_resource_TerminateSout( p_resource );
 504     input_resource_ResetAout( p_resource );
 505     input_resource_TerminateVout( p_resource );
 506 }
 507