git.sesse.net Git - vlc/blob - src/control/media_instance.c

   1 /*****************************************************************************
   2  * media_instance.c: Libvlc API Media Instance management functions
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.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 #include <vlc/libvlc.h>
  25 #include <vlc_demux.h>
  26 #include <vlc_input.h>
  27 #include "input/input_internal.h"
  28 #include "libvlc_internal.h"
  29
  30 /*
  31  * Release the associated input thread
  32  *
  33  * Object lock is NOT held.
  34  */
  35 static void release_input_thread( libvlc_media_instance_t *p_mi )
  36 {
  37     input_thread_t *p_input_thread;
  38     vlc_bool_t should_destroy;
  39
  40     if( !p_mi || p_mi->i_input_id == -1 )
  41         return;
  42
  43     p_input_thread = (input_thread_t*)vlc_object_get(
  44                                              p_mi->p_libvlc_instance->p_libvlc_int,
  45                                              p_mi->i_input_id );
  46
  47     p_mi->i_input_id = -1;
  48
  49     if( !p_input_thread )
  50         return;
  51
  52     /* release for previous vlc_object_get */
  53     vlc_object_release( p_input_thread );
  54
  55     should_destroy = p_input_thread->p_internals->i_refcount == 1;
  56
  57     /* release for initial p_input_thread yield (see _new()) */
  58     vlc_object_release( p_input_thread );
  59
  60     /* No one is tracking this input_thread appart us. Destroy it */
  61     if( should_destroy )
  62     {
  63         /* We owned this one */
  64         input_StopThread( p_input_thread );
  65         var_Destroy( p_input_thread, "drawable" );
  66         input_DestroyThread( p_input_thread );
  67     }
  68     else
  69     {
  70         /* XXX: hack the playlist doesn't retain the input thread,
  71          * so we did it for the playlist (see _new_from_input_thread),
  72          * revert that here. */
  73         vlc_object_release( p_input_thread );
  74     }
  75 }
  76
  77 /*
  78  * Retrieve the input thread. Be sure to release the object
  79  * once you are done with it. (libvlc Internal)
  80  *
  81  * Object lock is held.
  82  */
  83 input_thread_t *libvlc_get_input_thread( libvlc_media_instance_t *p_mi,
  84                                          libvlc_exception_t *p_e )
  85 {
  86     input_thread_t *p_input_thread;
  87
  88     vlc_mutex_lock( &p_mi->object_lock );
  89
  90     if( !p_mi || p_mi->i_input_id == -1 )
  91     {
  92         vlc_mutex_unlock( &p_mi->object_lock );
  93         RAISENULL( "Input is NULL" );
  94     }
  95
  96     p_input_thread = (input_thread_t*)vlc_object_get(
  97                                              p_mi->p_libvlc_instance->p_libvlc_int,
  98                                              p_mi->i_input_id );
  99     if( !p_input_thread )
 100     {
 101         vlc_mutex_unlock( &p_mi->object_lock );
 102         RAISENULL( "Input does not exist" );
 103     }
 104
 105     vlc_mutex_unlock( &p_mi->object_lock );
 106     return p_input_thread;
 107 }
 108
 109 /*
 110  * input_state_changed (Private) (input var "state" Callback)
 111  */
 112 static int
 113 input_state_changed( vlc_object_t * p_this, char const * psz_cmd,
 114                      vlc_value_t oldval, vlc_value_t newval,
 115                      void * p_userdata )
 116 {
 117     libvlc_media_instance_t * p_mi = p_userdata;
 118     libvlc_event_t event;
 119
 120     if( newval.i_int == oldval.i_int )
 121         return VLC_SUCCESS; /* No change since last time, don't propagate */
 122
 123     switch ( newval.i_int )
 124     {
 125         case END_S:
 126             event.type = libvlc_MediaInstanceReachedEnd;
 127             break;
 128         case PAUSE_S:
 129             event.type = libvlc_MediaInstancePaused;
 130             break;
 131         case PLAYING_S:
 132             event.type = libvlc_MediaInstancePlayed;
 133             break;
 134         default:
 135             return VLC_SUCCESS;
 136     }
 137
 138     libvlc_event_send( p_mi->p_event_manager, &event );
 139     return VLC_SUCCESS;
 140 }
 141
 142 /*
 143  * input_position_changed (Private) (input var "intf-change" Callback)
 144  */
 145 static int
 146 input_position_changed( vlc_object_t * p_this, char const * psz_cmd,
 147                      vlc_value_t oldval, vlc_value_t newval,
 148                      void * p_userdata )
 149 {
 150     libvlc_media_instance_t * p_mi = p_userdata;
 151     vlc_value_t val;
 152
 153     if (!strcmp(psz_cmd, "intf" /* "-change" no need to go further */))
 154     {
 155         input_thread_t * p_input = (input_thread_t *)p_this;
 156         var_Get( p_input, "position", &val );
 157
 158         if ((val.i_time % I64C(500000)) != 0)
 159             return VLC_SUCCESS; /* No need to have a better precision */
 160         var_Get( p_input, "state", &val );
 161
 162         if( val.i_int != PLAYING_S )
 163             return VLC_SUCCESS; /* Don't send the position while stopped */
 164     }
 165     else
 166         val.i_time = newval.i_time;
 167
 168     libvlc_event_t event;
 169     event.type = libvlc_MediaInstancePositionChanged;
 170     event.u.media_instance_position_changed.new_position = val.i_time;
 171
 172     libvlc_event_send( p_mi->p_event_manager, &event );
 173     return VLC_SUCCESS;
 174 }
 175
 176 /**************************************************************************
 177  * Create a Media Instance object
 178  **************************************************************************/
 179 libvlc_media_instance_t *
 180 libvlc_media_instance_new( libvlc_instance_t * p_libvlc_instance,
 181                            libvlc_exception_t * p_e )
 182 {
 183     libvlc_media_instance_t * p_mi;
 184
 185     if( !p_libvlc_instance )
 186     {
 187         libvlc_exception_raise( p_e, "invalid libvlc instance" );
 188         return NULL;
 189     }
 190
 191     p_mi = malloc( sizeof(libvlc_media_instance_t) );
 192     p_mi->p_md = NULL;
 193     p_mi->drawable = 0;
 194     p_mi->p_libvlc_instance = p_libvlc_instance;
 195     p_mi->i_input_id = -1;
 196     /* refcount strategy:
 197      * - All items created by _new start with a refcount set to 1
 198      * - Accessor _release decrease the refcount by 1, if after that
 199      *   operation the refcount is 0, the object is destroyed.
 200      * - Accessor _retain increase the refcount by 1 (XXX: to implement) */
 201     p_mi->i_refcount = 1;
 202     /* object_lock strategy:
 203      * - No lock held in constructor
 204      * - Lock when accessing all variable this lock is held
 205      * - Lock when attempting to destroy the object the lock is also held */
 206     vlc_mutex_init( p_mi->p_libvlc_instance->p_libvlc_int,
 207                     &p_mi->object_lock );
 208     p_mi->p_event_manager = libvlc_event_manager_new( p_mi,
 209             p_libvlc_instance, p_e );
 210     if( libvlc_exception_raised( p_e ) )
 211     {
 212         free( p_mi );
 213         return NULL;
 214     }
 215
 216     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 217             libvlc_MediaInstanceReachedEnd, p_e );
 218
 219     return p_mi;
 220 }
 221
 222 /**************************************************************************
 223  * Create a Media Instance object with a media descriptor
 224  **************************************************************************/
 225 libvlc_media_instance_t *
 226 libvlc_media_instance_new_from_media_descriptor(
 227                                     libvlc_media_descriptor_t * p_md,
 228                                     libvlc_exception_t *p_e )
 229 {
 230     libvlc_media_instance_t * p_mi;
 231     p_mi = libvlc_media_instance_new( p_md->p_libvlc_instance, p_e );
 232
 233     if( !p_mi )
 234         return NULL;
 235
 236     libvlc_media_descriptor_retain( p_md );
 237     p_mi->p_md = p_md;
 238
 239     return p_mi;
 240 }
 241
 242 /**************************************************************************
 243  * Create a new media instance object from an input_thread (Libvlc Internal)
 244  **************************************************************************/
 245 libvlc_media_instance_t * libvlc_media_instance_new_from_input_thread(
 246                                    struct libvlc_instance_t *p_libvlc_instance,
 247                                    input_thread_t *p_input,
 248                                    libvlc_exception_t *p_e )
 249 {
 250     libvlc_media_instance_t * p_mi;
 251
 252     if( !p_input )
 253     {
 254         libvlc_exception_raise( p_e, "invalid input thread" );
 255         return NULL;
 256     }
 257
 258     p_mi = libvlc_media_instance_new( p_libvlc_instance, p_e );
 259
 260     if( !p_mi )
 261         return NULL;
 262
 263     p_mi->p_md = libvlc_media_descriptor_new_from_input_item(
 264                     p_libvlc_instance,
 265                     p_input->p->input.p_item, p_e );
 266
 267     if( !p_mi->p_md )
 268     {
 269         libvlc_media_instance_destroy( p_mi );
 270         return NULL;
 271     }
 272
 273     p_mi->i_input_id = p_input->i_object_id;
 274
 275     /* will be released in media_instance_release() */
 276     vlc_object_yield( p_input );
 277
 278     /* XXX: Hack as the playlist doesn't yield the input thread we retain
 279      * the input for the playlist. (see corresponding hack in _release) */
 280     vlc_object_yield( p_input );
 281
 282     return p_mi;
 283 }
 284
 285 /**************************************************************************
 286  * Destroy a Media Instance object (libvlc internal)
 287  *
 288  * Warning: No lock held here, but hey, this is internal.
 289  **************************************************************************/
 290 void libvlc_media_instance_destroy( libvlc_media_instance_t *p_mi )
 291 {
 292     input_thread_t *p_input_thread;
 293     libvlc_exception_t p_e;
 294
 295     libvlc_exception_init( &p_e );
 296
 297     if( !p_mi )
 298         return;
 299
 300     p_input_thread = libvlc_get_input_thread( p_mi, &p_e );
 301
 302     if( libvlc_exception_raised( &p_e ) )
 303     {
 304         libvlc_event_manager_release( p_mi->p_event_manager );
 305         free( p_mi );
 306         return; /* no need to worry about no input thread */
 307     }
 308     vlc_mutex_destroy( &p_mi->object_lock );
 309
 310     input_DestroyThread( p_input_thread );
 311
 312     libvlc_media_descriptor_release( p_mi->p_md );
 313
 314     free( p_mi );
 315 }
 316
 317 /**************************************************************************
 318  * Release a Media Instance object
 319  **************************************************************************/
 320 void libvlc_media_instance_release( libvlc_media_instance_t *p_mi )
 321 {
 322     if( !p_mi )
 323         return;
 324
 325     vlc_mutex_lock( &p_mi->object_lock );
 326
 327     p_mi->i_refcount--;
 328
 329     if( p_mi->i_refcount > 0 )
 330     {
 331         vlc_mutex_unlock( &p_mi->object_lock );
 332         return;
 333     }
 334     vlc_mutex_unlock( &p_mi->object_lock );
 335     vlc_mutex_destroy( &p_mi->object_lock );
 336
 337     libvlc_event_manager_release( p_mi->p_event_manager );
 338
 339     release_input_thread( p_mi );
 340
 341     libvlc_media_descriptor_release( p_mi->p_md );
 342
 343     free( p_mi );
 344 }
 345
 346 /**************************************************************************
 347  * Retain a Media Instance object
 348  **************************************************************************/
 349 void libvlc_media_instance_retain( libvlc_media_instance_t *p_mi )
 350 {
 351     if( !p_mi )
 352         return;
 353
 354     p_mi->i_refcount++;
 355 }
 356 /**************************************************************************
 357  * Set the Media descriptor associated with the instance
 358  **************************************************************************/
 359 void libvlc_media_instance_set_media_descriptor(
 360                             libvlc_media_instance_t *p_mi,
 361                             libvlc_media_descriptor_t *p_md,
 362                             libvlc_exception_t *p_e )
 363 {
 364     (void)p_e;
 365
 366     if( !p_mi )
 367         return;
 368
 369     vlc_mutex_lock( &p_mi->object_lock );
 370
 371     release_input_thread( p_mi );
 372
 373     libvlc_media_descriptor_release( p_mi->p_md );
 374
 375     if( !p_md )
 376     {
 377         p_mi->p_md = NULL;
 378         vlc_mutex_unlock( &p_mi->object_lock );
 379         return; /* It is ok to pass a NULL md */
 380     }
 381
 382     libvlc_media_descriptor_retain( p_md );
 383     p_mi->p_md = p_md;
 384
 385     /* The policy here is to ignore that we were created using a different
 386      * libvlc_instance, because we don't really care */
 387     p_mi->p_libvlc_instance = p_md->p_libvlc_instance;
 388
 389     vlc_mutex_unlock( &p_mi->object_lock );
 390 }
 391
 392 /**************************************************************************
 393  * Get the Media descriptor associated with the instance
 394  **************************************************************************/
 395 libvlc_media_descriptor_t *
 396 libvlc_media_instance_get_media_descriptor(
 397                             libvlc_media_instance_t *p_mi,
 398                             libvlc_exception_t *p_e )
 399 {
 400     (void)p_e;
 401
 402     if( !p_mi->p_md )
 403         return NULL;
 404
 405     libvlc_media_descriptor_retain( p_mi->p_md );
 406     return p_mi->p_md;
 407 }
 408
 409 /**************************************************************************
 410  * Get the event Manager
 411  **************************************************************************/
 412 libvlc_event_manager_t *
 413 libvlc_media_instance_event_manager(
 414                             libvlc_media_instance_t *p_mi,
 415                             libvlc_exception_t *p_e )
 416 {
 417     (void)p_e;
 418
 419     return p_mi->p_event_manager;
 420 }
 421
 422 /**************************************************************************
 423  * Play
 424  **************************************************************************/
 425 void libvlc_media_instance_play( libvlc_media_instance_t *p_mi,
 426                                  libvlc_exception_t *p_e )
 427 {
 428     input_thread_t * p_input_thread;
 429
 430     if( (p_input_thread = libvlc_get_input_thread( p_mi, p_e )) )
 431     {
 432         /* A thread alread exists, send it a play message */
 433         input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
 434         vlc_object_release( p_input_thread );
 435         return;
 436     }
 437
 438     /* Ignore previous exception */
 439     libvlc_exception_clear( p_e );
 440
 441     vlc_mutex_lock( &p_mi->object_lock );
 442
 443     if( !p_mi->p_md )
 444     {
 445         libvlc_exception_raise( p_e, "no associated media descriptor" );
 446         vlc_mutex_unlock( &p_mi->object_lock );
 447         return;
 448     }
 449
 450     p_input_thread = input_CreateThread( p_mi->p_libvlc_instance->p_libvlc_int,
 451                                          p_mi->p_md->p_input_item );
 452     p_mi->i_input_id = p_input_thread->i_object_id;
 453
 454     if( p_mi->drawable )
 455     {
 456         vlc_value_t val;
 457         val.i_int = p_mi->drawable;
 458         var_Create( p_input_thread, "drawable", VLC_VAR_DOINHERIT );
 459         var_Set( p_input_thread, "drawable", val );
 460     }
 461     var_AddCallback( p_input_thread, "state", input_state_changed, p_mi );
 462     var_AddCallback( p_input_thread, "intf-change", input_position_changed, p_mi );
 463
 464     /* will be released in media_instance_release() */
 465     vlc_object_yield( p_input_thread );
 466
 467     vlc_mutex_unlock( &p_mi->object_lock );
 468 }
 469
 470 /**************************************************************************
 471  * Pause
 472  **************************************************************************/
 473 void libvlc_media_instance_pause( libvlc_media_instance_t *p_mi,
 474                                   libvlc_exception_t *p_e )
 475 {
 476     input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 477
 478     if( !p_input_thread )
 479         return;
 480
 481     input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S );
 482     vlc_object_release( p_input_thread );
 483 }
 484
 485 /**************************************************************************
 486  * Stop
 487  **************************************************************************/
 488 void libvlc_media_instance_stop( libvlc_media_instance_t *p_mi,
 489                                  libvlc_exception_t *p_e )
 490 {
 491     //libvlc_exception_raise( p_e, "Not implemented" );
 492 }
 493
 494 /**************************************************************************
 495  * Set Drawable
 496  **************************************************************************/
 497 void libvlc_media_instance_set_drawable( libvlc_media_instance_t *p_mi,
 498                                          libvlc_drawable_t drawable,
 499                                          libvlc_exception_t *p_e )
 500 {
 501     p_mi->drawable = drawable;
 502 }
 503
 504 /**************************************************************************
 505  * Getters for stream information
 506  **************************************************************************/
 507 vlc_int64_t libvlc_media_instance_get_length(
 508                              libvlc_media_instance_t *p_mi,
 509                              libvlc_exception_t *p_e )
 510 {
 511     input_thread_t *p_input_thread;
 512     vlc_value_t val;
 513
 514     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 515     if( !p_input_thread )
 516         return -1;
 517
 518     var_Get( p_input_thread, "length", &val );
 519     vlc_object_release( p_input_thread );
 520
 521     return (val.i_time+500LL)/1000LL;
 522 }
 523
 524 vlc_int64_t libvlc_media_instance_get_time(
 525                                    libvlc_media_instance_t *p_mi,
 526                                    libvlc_exception_t *p_e )
 527 {
 528     input_thread_t *p_input_thread;
 529     vlc_value_t val;
 530
 531     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 532     if( !p_input_thread )
 533         return -1;
 534
 535     var_Get( p_input_thread , "time", &val );
 536     vlc_object_release( p_input_thread );
 537     return (val.i_time+500LL)/1000LL;
 538 }
 539
 540 void libvlc_media_instance_set_time(
 541                                  libvlc_media_instance_t *p_mi,
 542                                  vlc_int64_t time,
 543                                  libvlc_exception_t *p_e )
 544 {
 545     input_thread_t *p_input_thread;
 546     vlc_value_t value;
 547
 548     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 549     if( !p_input_thread )
 550         return;
 551
 552     value.i_time = time*1000LL;
 553     var_Set( p_input_thread, "time", value );
 554     vlc_object_release( p_input_thread );
 555 }
 556
 557 void libvlc_media_instance_set_position(
 558                                 libvlc_media_instance_t *p_mi,
 559                                 float position,
 560                                 libvlc_exception_t *p_e )
 561 {
 562     input_thread_t *p_input_thread;
 563     vlc_value_t val;
 564     val.f_float = position;
 565
 566     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 567     if( !p_input_thread )
 568         return;
 569
 570     var_Set( p_input_thread, "position", val );
 571     vlc_object_release( p_input_thread );
 572 }
 573
 574 float libvlc_media_instance_get_position(
 575                                  libvlc_media_instance_t *p_mi,
 576                                  libvlc_exception_t *p_e )
 577 {
 578     input_thread_t *p_input_thread;
 579     vlc_value_t val;
 580
 581     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 582     if( !p_input_thread )
 583         return -1.0;
 584
 585     var_Get( p_input_thread, "position", &val );
 586     vlc_object_release( p_input_thread );
 587
 588     return val.f_float;
 589 }
 590
 591 float libvlc_media_instance_get_fps(
 592                                  libvlc_media_instance_t *p_mi,
 593                                  libvlc_exception_t *p_e)
 594 {
 595     double f_fps = 0.0;
 596     input_thread_t *p_input_thread;
 597
 598     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 599     if( !p_input_thread )
 600         return 0.0;
 601
 602     if( (NULL == p_input_thread->p->input.p_demux)
 603         || demux2_Control( p_input_thread->p->input.p_demux, DEMUX_GET_FPS, &f_fps )
 604         || f_fps < 0.1 )
 605     {
 606         vlc_object_release( p_input_thread );
 607         return 0.0;
 608     }
 609     else
 610     {
 611         vlc_object_release( p_input_thread );
 612         return( f_fps );
 613     }
 614 }
 615
 616 vlc_bool_t libvlc_media_instance_will_play(
 617                                  libvlc_media_instance_t *p_mi,
 618                                  libvlc_exception_t *p_e)
 619 {
 620     input_thread_t *p_input_thread =
 621                             libvlc_get_input_thread ( p_mi, p_e);
 622     if ( !p_input_thread )
 623         return VLC_FALSE;
 624
 625     if ( !p_input_thread->b_die && !p_input_thread->b_dead )
 626     {
 627         vlc_object_release( p_input_thread );
 628         return VLC_TRUE;
 629     }
 630     vlc_object_release( p_input_thread );
 631     return VLC_FALSE;
 632 }
 633
 634 void libvlc_media_instance_set_rate(
 635                                  libvlc_media_instance_t *p_mi,
 636                                  float rate,
 637                                  libvlc_exception_t *p_e )
 638 {
 639     input_thread_t *p_input_thread;
 640     vlc_value_t val;
 641
 642     if( rate <= 0 )
 643         RAISEVOID( "Rate value is invalid" );
 644
 645     val.i_int = 1000.0f/rate;
 646
 647     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 648     if ( !p_input_thread )
 649         return;
 650
 651     var_Set( p_input_thread, "rate", val );
 652     vlc_object_release( p_input_thread );
 653 }
 654
 655 float libvlc_media_instance_get_rate(
 656                                  libvlc_media_instance_t *p_mi,
 657                                  libvlc_exception_t *p_e )
 658 {
 659     input_thread_t *p_input_thread;
 660     vlc_value_t val;
 661
 662     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 663     if ( !p_input_thread )
 664         return -1.0;
 665
 666     var_Get( p_input_thread, "rate", &val );
 667     vlc_object_release( p_input_thread );
 668
 669     return (float)1000.0f/val.i_int;
 670 }
 671
 672 static libvlc_state_t vlc_to_libvlc_state[] =
 673 {
 674     [INIT_S]        = libvlc_Opening,
 675     [OPENING_S]     = libvlc_Opening,
 676     [BUFFERING_S]   = libvlc_Buffering,
 677     [PLAYING_S]     = libvlc_Playing,
 678     [PAUSE_S]       = libvlc_Paused,
 679     [END_S]         = libvlc_Ended,
 680     [ERROR_S]       = libvlc_Error,
 681 };
 682
 683 libvlc_state_t libvlc_media_instance_get_state(
 684                                  libvlc_media_instance_t *p_mi,
 685                                  libvlc_exception_t *p_e )
 686 {
 687     input_thread_t *p_input_thread;
 688     vlc_value_t val;
 689
 690     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 691     if ( !p_input_thread )
 692         return libvlc_Stopped;
 693
 694     var_Get( p_input_thread, "state", &val );
 695     vlc_object_release( p_input_thread );
 696
 697     if( val.i_int < 0 || val.i_int > 6 )
 698         return libvlc_Stopped;
 699
 700     return vlc_to_libvlc_state[val.i_int];
 701 }