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

   1 /*****************************************************************************
   2  * media_player.c: Libvlc API Media Instance management functions
   3  *****************************************************************************
   4  * Copyright (C) 2005-2009 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 "libvlc_internal.h"
  25
  26 #include <vlc/libvlc.h>
  27 #include <vlc_demux.h>
  28 #include <vlc_input.h>
  29 #include <vlc_vout.h>
  30 #include "libvlc.h"
  31 #include <assert.h>
  32
  33 static int
  34 input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd,
  35                         vlc_value_t oldval, vlc_value_t newval,
  36                         void * p_userdata );
  37 static int
  38 input_pausable_changed( vlc_object_t * p_this, char const * psz_cmd,
  39                         vlc_value_t oldval, vlc_value_t newval,
  40                         void * p_userdata );
  41 static int
  42 input_event_changed( vlc_object_t * p_this, char const * psz_cmd,
  43                      vlc_value_t oldval, vlc_value_t newval,
  44                      void * p_userdata );
  45
  46 static int SnapshotTakenCallback( vlc_object_t *p_this, char const *psz_cmd,
  47                        vlc_value_t oldval, vlc_value_t newval, void *p_data );
  48
  49 static const libvlc_state_t vlc_to_libvlc_state_array[] =
  50 {
  51     [INIT_S]        = libvlc_NothingSpecial,
  52     [OPENING_S]     = libvlc_Opening,
  53     [PLAYING_S]     = libvlc_Playing,
  54     [PAUSE_S]       = libvlc_Paused,
  55     [END_S]         = libvlc_Ended,
  56     [ERROR_S]       = libvlc_Error,
  57 };
  58
  59 static inline libvlc_state_t vlc_to_libvlc_state( int vlc_state )
  60 {
  61     if( vlc_state < 0 || vlc_state > 6 )
  62         return libvlc_Ended;
  63
  64     return vlc_to_libvlc_state_array[vlc_state];
  65 }
  66
  67 /*
  68  * Release the associated input thread.
  69  *
  70  * Object lock is NOT held.
  71  */
  72 static void release_input_thread( libvlc_media_player_t *p_mi, bool b_input_abort )
  73 {
  74     input_thread_t * p_input_thread;
  75
  76     if( !p_mi || !p_mi->p_input_thread )
  77         return;
  78
  79     p_input_thread = p_mi->p_input_thread;
  80
  81     /* No one is tracking this input_thread apart from us. Destroy it. */
  82     if( p_mi->b_own_its_input_thread )
  83     {
  84         var_DelCallback( p_input_thread, "can-seek",
  85                          input_seekable_changed, p_mi );
  86         var_DelCallback( p_input_thread, "can-pause",
  87                          input_pausable_changed, p_mi );
  88         var_DelCallback( p_input_thread, "intf-event",
  89                          input_event_changed, p_mi );
  90
  91         /* We owned this one */
  92         input_Stop( p_input_thread, b_input_abort );
  93         vlc_thread_join( p_input_thread );
  94
  95         var_Destroy( p_input_thread, "drawable-hwnd" );
  96         var_Destroy( p_input_thread, "drawable-xid" );
  97         var_Destroy( p_input_thread, "drawable-agl" );
  98     }
  99
 100     vlc_object_release( p_input_thread );
 101
 102     p_mi->p_input_thread = NULL;
 103 }
 104
 105 /*
 106  * Retrieve the input thread. Be sure to release the object
 107  * once you are done with it. (libvlc Internal)
 108  *
 109  * Function will lock the object.
 110  */
 111 input_thread_t *libvlc_get_input_thread( libvlc_media_player_t *p_mi,
 112                                          libvlc_exception_t *p_e )
 113 {
 114     input_thread_t *p_input_thread;
 115
 116     if( !p_mi ) RAISENULL( "Media Instance is NULL" );
 117
 118     vlc_mutex_lock( &p_mi->object_lock );
 119
 120     if( !p_mi->p_input_thread )
 121     {
 122         vlc_mutex_unlock( &p_mi->object_lock );
 123         RAISENULL( "Input is NULL" );
 124     }
 125
 126     p_input_thread = p_mi->p_input_thread;
 127     vlc_object_hold( p_input_thread );
 128
 129     vlc_mutex_unlock( &p_mi->object_lock );
 130
 131     return p_input_thread;
 132 }
 133
 134 static int
 135 input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd,
 136                         vlc_value_t oldval, vlc_value_t newval,
 137                         void * p_userdata )
 138 {
 139     VLC_UNUSED(oldval);
 140     VLC_UNUSED(p_this);
 141     VLC_UNUSED(psz_cmd);
 142     libvlc_media_player_t * p_mi = p_userdata;
 143     libvlc_event_t event;
 144
 145     libvlc_media_set_state( p_mi->p_md, libvlc_NothingSpecial, NULL);
 146     event.type = libvlc_MediaPlayerSeekableChanged;
 147     event.u.media_player_seekable_changed.new_seekable = newval.b_bool;
 148
 149     libvlc_event_send( p_mi->p_event_manager, &event );
 150     return VLC_SUCCESS;
 151 }
 152
 153 static int
 154 input_pausable_changed( vlc_object_t * p_this, char const * psz_cmd,
 155                         vlc_value_t oldval, vlc_value_t newval,
 156                         void * p_userdata )
 157 {
 158     VLC_UNUSED(oldval);
 159     VLC_UNUSED(p_this);
 160     VLC_UNUSED(psz_cmd);
 161     libvlc_media_player_t * p_mi = p_userdata;
 162     libvlc_event_t event;
 163
 164     libvlc_media_set_state( p_mi->p_md, libvlc_NothingSpecial, NULL);
 165     event.type = libvlc_MediaPlayerPausableChanged;
 166     event.u.media_player_pausable_changed.new_pausable = newval.b_bool;
 167
 168     libvlc_event_send( p_mi->p_event_manager, &event );
 169     return VLC_SUCCESS;
 170 }
 171
 172 static int
 173 input_event_changed( vlc_object_t * p_this, char const * psz_cmd,
 174                      vlc_value_t oldval, vlc_value_t newval,
 175                      void * p_userdata )
 176 {
 177     VLC_UNUSED(oldval);
 178     input_thread_t * p_input = (input_thread_t *)p_this;
 179     libvlc_media_player_t * p_mi = p_userdata;
 180     libvlc_event_t event;
 181
 182     assert( !strcmp( psz_cmd, "intf-event" ) );
 183
 184     if( newval.i_int == INPUT_EVENT_STATE )
 185     {
 186         libvlc_state_t libvlc_state;
 187
 188         switch ( var_GetInteger( p_input, "state" ) )
 189         {
 190             case INIT_S:
 191                 libvlc_state = libvlc_NothingSpecial;
 192                 event.type = libvlc_MediaPlayerNothingSpecial;
 193                 break;
 194             case OPENING_S:
 195                 libvlc_state = libvlc_Opening;
 196                 event.type = libvlc_MediaPlayerOpening;
 197                 break;
 198             case PLAYING_S:
 199                 libvlc_state = libvlc_Playing;
 200                 event.type = libvlc_MediaPlayerPlaying;
 201                 break;
 202             case PAUSE_S:
 203                 libvlc_state = libvlc_Paused;
 204                 event.type = libvlc_MediaPlayerPaused;
 205                 break;
 206             case END_S:
 207                 libvlc_state = libvlc_Ended;
 208                 event.type = libvlc_MediaPlayerEndReached;
 209                 break;
 210             case ERROR_S:
 211                 libvlc_state = libvlc_Error;
 212                 event.type = libvlc_MediaPlayerEncounteredError;
 213                 break;
 214
 215             default:
 216                 return VLC_SUCCESS;
 217         }
 218
 219         libvlc_media_set_state( p_mi->p_md, libvlc_state, NULL );
 220         libvlc_event_send( p_mi->p_event_manager, &event );
 221     }
 222     else if( newval.i_int == INPUT_EVENT_POSITION )
 223     {
 224         if( var_GetInteger( p_input, "state" ) != PLAYING_S )
 225             return VLC_SUCCESS; /* Don't send the position while stopped */
 226
 227         /* */
 228         event.type = libvlc_MediaPlayerPositionChanged;
 229         event.u.media_player_position_changed.new_position =
 230                                           var_GetFloat( p_input, "position" );
 231         libvlc_event_send( p_mi->p_event_manager, &event );
 232
 233         /* */
 234         event.type = libvlc_MediaPlayerTimeChanged;
 235         event.u.media_player_time_changed.new_time =
 236                                                var_GetTime( p_input, "time" );
 237         libvlc_event_send( p_mi->p_event_manager, &event );
 238     }
 239
 240     return VLC_SUCCESS;
 241
 242 }
 243
 244 /**************************************************************************
 245  * Create a Media Instance object.
 246  *
 247  * Refcount strategy:
 248  * - All items created by _new start with a refcount set to 1.
 249  * - Accessor _release decrease the refcount by 1, if after that
 250  *   operation the refcount is 0, the object is destroyed.
 251  * - Accessor _retain increase the refcount by 1 (XXX: to implement)
 252  *
 253  * Object locking strategy:
 254  * - No lock held while in constructor.
 255  * - When accessing any member variable this lock is held. (XXX who locks?)
 256  * - When attempting to destroy the object the lock is also held.
 257  **************************************************************************/
 258 libvlc_media_player_t *
 259 libvlc_media_player_new( libvlc_instance_t * p_libvlc_instance,
 260                            libvlc_exception_t * p_e )
 261 {
 262     libvlc_media_player_t * p_mi;
 263
 264     if( !p_libvlc_instance )
 265     {
 266         libvlc_exception_raise( p_e, "invalid libvlc instance" );
 267         return NULL;
 268     }
 269
 270     p_mi = malloc( sizeof(libvlc_media_player_t) );
 271     if( !p_mi )
 272     {
 273         libvlc_exception_raise( p_e, "Not enough memory" );
 274         return NULL;
 275     }
 276     p_mi->p_md = NULL;
 277     p_mi->drawable.agl = 0;
 278     p_mi->drawable.xid = 0;
 279     p_mi->drawable.hwnd = NULL;
 280     p_mi->p_libvlc_instance = p_libvlc_instance;
 281     p_mi->p_input_thread = NULL;
 282     p_mi->i_refcount = 1;
 283     p_mi->b_own_its_input_thread = true;
 284     vlc_mutex_init( &p_mi->object_lock );
 285     p_mi->p_event_manager = libvlc_event_manager_new( p_mi,
 286             p_libvlc_instance, p_e );
 287     if( libvlc_exception_raised( p_e ) )
 288     {
 289         vlc_mutex_destroy( &p_mi->object_lock );
 290         free( p_mi );
 291         return NULL;
 292     }
 293
 294     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 295             libvlc_MediaPlayerNothingSpecial, p_e );
 296     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 297             libvlc_MediaPlayerOpening, p_e );
 298     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 299             libvlc_MediaPlayerBuffering, p_e );
 300     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 301             libvlc_MediaPlayerPlaying, p_e );
 302     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 303             libvlc_MediaPlayerPaused, p_e );
 304     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 305             libvlc_MediaPlayerStopped, p_e );
 306     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 307             libvlc_MediaPlayerForward, p_e );
 308     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 309             libvlc_MediaPlayerBackward, p_e );
 310     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 311             libvlc_MediaPlayerEndReached, p_e );
 312     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 313             libvlc_MediaPlayerEncounteredError, p_e );
 314
 315     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 316             libvlc_MediaPlayerPositionChanged, p_e );
 317     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 318             libvlc_MediaPlayerTimeChanged, p_e );
 319     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 320             libvlc_MediaPlayerTitleChanged, p_e );
 321     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 322             libvlc_MediaPlayerSeekableChanged, p_e );
 323     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 324             libvlc_MediaPlayerPausableChanged, p_e );
 325
 326     /* Snapshot initialization */
 327     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
 328            libvlc_MediaPlayerSnapshotTaken, p_e );
 329
 330     /* Attach a var callback to the global object to provide the glue between
 331         vout_thread that generates the event and media_player that re-emits it
 332         with its own event manager
 333     */
 334     var_Create( p_libvlc_instance->p_libvlc_int, "vout-snapshottaken",
 335                 VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 336     var_AddCallback( p_libvlc_instance->p_libvlc_int, "vout-snapshottaken",
 337                      SnapshotTakenCallback, p_mi );
 338
 339     return p_mi;
 340 }
 341
 342 /**************************************************************************
 343  * Create a Media Instance object with a media descriptor.
 344  **************************************************************************/
 345 libvlc_media_player_t *
 346 libvlc_media_player_new_from_media(
 347                                     libvlc_media_t * p_md,
 348                                     libvlc_exception_t *p_e )
 349 {
 350     libvlc_media_player_t * p_mi;
 351
 352     p_mi = libvlc_media_player_new( p_md->p_libvlc_instance, p_e );
 353     if( !p_mi )
 354         return NULL;
 355
 356     libvlc_media_retain( p_md );
 357     p_mi->p_md = p_md;
 358
 359     return p_mi;
 360 }
 361
 362 /**************************************************************************
 363  * Create a new media instance object from an input_thread (Libvlc Internal).
 364  **************************************************************************/
 365 libvlc_media_player_t * libvlc_media_player_new_from_input_thread(
 366                                    struct libvlc_instance_t *p_libvlc_instance,
 367                                    input_thread_t *p_input,
 368                                    libvlc_exception_t *p_e )
 369 {
 370     libvlc_media_player_t * p_mi;
 371
 372     if( !p_input )
 373     {
 374         libvlc_exception_raise( p_e, "invalid input thread" );
 375         return NULL;
 376     }
 377
 378     p_mi = libvlc_media_player_new( p_libvlc_instance, p_e );
 379     if( !p_mi )
 380         return NULL;
 381
 382     p_mi->p_md = libvlc_media_new_from_input_item(
 383                     p_libvlc_instance,
 384                     input_GetItem( p_input ), p_e );
 385     if( !p_mi->p_md )
 386     {
 387         libvlc_media_player_destroy( p_mi );
 388         return NULL;
 389     }
 390
 391     /* will be released in media_player_release() */
 392     vlc_object_hold( p_input );
 393
 394     p_mi->p_input_thread = p_input;
 395     p_mi->b_own_its_input_thread = false;
 396
 397     return p_mi;
 398 }
 399
 400 /**************************************************************************
 401  * Destroy a Media Instance object (libvlc internal)
 402  *
 403  * Warning: No lock held here, but hey, this is internal. Caller must lock.
 404  **************************************************************************/
 405 void libvlc_media_player_destroy( libvlc_media_player_t *p_mi )
 406 {
 407     input_thread_t *p_input_thread;
 408     libvlc_exception_t p_e;
 409
 410     if( !p_mi )
 411         return;
 412
 413     libvlc_exception_init( &p_e );
 414
 415         /* Detach Callback from the main libvlc object */
 416     var_DelCallback( p_mi->p_libvlc_instance->p_libvlc_int,
 417                      "vout-snapshottaken", SnapshotTakenCallback, p_mi );
 418
 419     p_input_thread = libvlc_get_input_thread( p_mi, &p_e );
 420
 421     if( libvlc_exception_raised( &p_e ) )
 422     {
 423         libvlc_event_manager_release( p_mi->p_event_manager );
 424         libvlc_exception_clear( &p_e );
 425         free( p_mi );
 426         return; /* no need to worry about no input thread */
 427     }
 428     vlc_mutex_destroy( &p_mi->object_lock );
 429
 430     vlc_object_release( p_input_thread );
 431
 432     libvlc_media_release( p_mi->p_md );
 433
 434     free( p_mi );
 435 }
 436
 437 /**************************************************************************
 438  * Release a Media Instance object.
 439  *
 440  * Function does the locking.
 441  **************************************************************************/
 442 void libvlc_media_player_release( libvlc_media_player_t *p_mi )
 443 {
 444     if( !p_mi )
 445         return;
 446
 447     vlc_mutex_lock( &p_mi->object_lock );
 448
 449     p_mi->i_refcount--;
 450
 451     if( p_mi->i_refcount > 0 )
 452     {
 453         vlc_mutex_unlock( &p_mi->object_lock );
 454         return;
 455     }
 456     vlc_mutex_unlock( &p_mi->object_lock );
 457
 458     /* Detach Callback from the main libvlc object */
 459     var_DelCallback( p_mi->p_libvlc_instance->p_libvlc_int,
 460                      "vout-snapshottaken", SnapshotTakenCallback, p_mi );
 461
 462     vlc_mutex_destroy( &p_mi->object_lock );
 463
 464     release_input_thread( p_mi, true );
 465
 466     libvlc_event_manager_release( p_mi->p_event_manager );
 467
 468     libvlc_media_release( p_mi->p_md );
 469
 470     free( p_mi );
 471 }
 472
 473 /**************************************************************************
 474  * Retain a Media Instance object.
 475  *
 476  * Caller must hold the lock.
 477  **************************************************************************/
 478 void libvlc_media_player_retain( libvlc_media_player_t *p_mi )
 479 {
 480     if( !p_mi )
 481         return;
 482
 483     p_mi->i_refcount++;
 484 }
 485
 486 /**************************************************************************
 487  * Set the Media descriptor associated with the instance.
 488  *
 489  * Enter without lock -- function will lock the object.
 490  **************************************************************************/
 491 void libvlc_media_player_set_media(
 492                             libvlc_media_player_t *p_mi,
 493                             libvlc_media_t *p_md,
 494                             libvlc_exception_t *p_e )
 495 {
 496     VLC_UNUSED(p_e);
 497
 498     if( !p_mi )
 499         return;
 500
 501     vlc_mutex_lock( &p_mi->object_lock );
 502
 503     /* FIXME I am not sure if it is a user request or on die(eof/error)
 504      * request here */
 505     release_input_thread( p_mi,
 506                           p_mi->p_input_thread &&
 507                           !p_mi->p_input_thread->b_eof &&
 508                           !p_mi->p_input_thread->b_error );
 509
 510     if( p_mi->p_md )
 511         libvlc_media_set_state( p_mi->p_md, libvlc_NothingSpecial, p_e );
 512
 513     libvlc_media_release( p_mi->p_md );
 514
 515     if( !p_md )
 516     {
 517         p_mi->p_md = NULL;
 518         vlc_mutex_unlock( &p_mi->object_lock );
 519         return; /* It is ok to pass a NULL md */
 520     }
 521
 522     libvlc_media_retain( p_md );
 523     p_mi->p_md = p_md;
 524
 525     /* The policy here is to ignore that we were created using a different
 526      * libvlc_instance, because we don't really care */
 527     p_mi->p_libvlc_instance = p_md->p_libvlc_instance;
 528
 529     vlc_mutex_unlock( &p_mi->object_lock );
 530 }
 531
 532 /**************************************************************************
 533  * Get the Media descriptor associated with the instance.
 534  **************************************************************************/
 535 libvlc_media_t *
 536 libvlc_media_player_get_media(
 537                             libvlc_media_player_t *p_mi,
 538                             libvlc_exception_t *p_e )
 539 {
 540     VLC_UNUSED(p_e);
 541
 542     if( !p_mi->p_md )
 543         return NULL;
 544
 545     libvlc_media_retain( p_mi->p_md );
 546     return p_mi->p_md;
 547 }
 548
 549 /**************************************************************************
 550  * Get the event Manager.
 551  **************************************************************************/
 552 libvlc_event_manager_t *
 553 libvlc_media_player_event_manager(
 554                             libvlc_media_player_t *p_mi,
 555                             libvlc_exception_t *p_e )
 556 {
 557     VLC_UNUSED(p_e);
 558
 559     return p_mi->p_event_manager;
 560 }
 561
 562 /**************************************************************************
 563  * Trigger a snapshot Taken Event.
 564  *************************************************************************/
 565 static int SnapshotTakenCallback( vlc_object_t *p_this, char const *psz_cmd,
 566                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 567 {
 568     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
 569     VLC_UNUSED(p_this) ;
 570
 571     libvlc_media_player_t* p_mi = (libvlc_media_player_t*) p_data ;
 572     libvlc_event_t event ;
 573     event.type = libvlc_MediaPlayerSnapshotTaken ;
 574     event.u.media_player_snapshot_taken.psz_filename = newval.psz_string ;
 575     /* Snapshot psz data is a vlc_variable owned by libvlc object .
 576          Its memmory management is taken care by the obj*/
 577     msg_Dbg( p_this, "about to emit libvlc_snapshot_taken.make psz_str=0x%p"
 578              " (%s)", event.u.media_player_snapshot_taken.psz_filename,
 579              event.u.media_player_snapshot_taken.psz_filename );
 580     libvlc_event_send( p_mi->p_event_manager, &event );
 581
 582     return VLC_SUCCESS;
 583 }
 584
 585 /**************************************************************************
 586  * Tell media player to start playing.
 587  **************************************************************************/
 588 void libvlc_media_player_play( libvlc_media_player_t *p_mi,
 589                                  libvlc_exception_t *p_e )
 590 {
 591     input_thread_t * p_input_thread;
 592
 593     if( (p_input_thread = libvlc_get_input_thread( p_mi, p_e )) )
 594     {
 595         /* A thread already exists, send it a play message */
 596         input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
 597         vlc_object_release( p_input_thread );
 598         return;
 599     }
 600
 601     /* Ignore previous exception */
 602     libvlc_exception_clear( p_e );
 603
 604     vlc_mutex_lock( &p_mi->object_lock );
 605
 606     if( !p_mi->p_md )
 607     {
 608         libvlc_exception_raise( p_e, "no associated media descriptor" );
 609         vlc_mutex_unlock( &p_mi->object_lock );
 610         return;
 611     }
 612
 613     p_mi->p_input_thread = input_Create( p_mi->p_libvlc_instance->p_libvlc_int,
 614                                          p_mi->p_md->p_input_item, NULL, NULL );
 615
 616     if( !p_mi->p_input_thread )
 617     {
 618         vlc_mutex_unlock( &p_mi->object_lock );
 619         return;
 620     }
 621
 622     p_input_thread = p_mi->p_input_thread;
 623
 624     var_Create( p_input_thread, "drawable-agl", VLC_VAR_INTEGER );
 625     if( p_mi->drawable.agl )
 626         var_SetInteger( p_input_thread, "drawable-agl", p_mi->drawable.agl );
 627
 628     var_Create( p_input_thread, "drawable-xid", VLC_VAR_INTEGER );
 629     if( p_mi->drawable.xid )
 630         var_SetInteger( p_input_thread, "drawable-xid", p_mi->drawable.xid );
 631
 632     var_Create( p_input_thread, "drawable-hwnd", VLC_VAR_ADDRESS );
 633     if( p_mi->drawable.hwnd != NULL )
 634     {
 635         vlc_value_t val = { .p_address = p_mi->drawable.hwnd };
 636         var_Set( p_input_thread, "drawable-hwnd", val );
 637     }
 638
 639         var_Create( p_input_thread, "drawable-nsobject", VLC_VAR_ADDRESS );
 640     if( p_mi->drawable.nsobject != NULL )
 641     {
 642         vlc_value_t val = { .p_address = p_mi->drawable.nsobject };
 643         var_Set( p_input_thread, "drawable-nsobject", val );
 644     }
 645
 646     var_AddCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi );
 647     var_AddCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi );
 648     var_AddCallback( p_input_thread, "intf-event", input_event_changed, p_mi );
 649
 650     if( input_Start( p_input_thread ) )
 651     {
 652         vlc_object_release( p_input_thread );
 653         p_mi->p_input_thread = NULL;
 654     }
 655
 656     vlc_mutex_unlock( &p_mi->object_lock );
 657 }
 658
 659 /**************************************************************************
 660  * Pause.
 661  **************************************************************************/
 662 void libvlc_media_player_pause( libvlc_media_player_t *p_mi,
 663                                   libvlc_exception_t *p_e )
 664 {
 665     input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 666     if( !p_input_thread )
 667         return;
 668
 669     libvlc_state_t state = libvlc_media_player_get_state( p_mi, p_e );
 670     if( state == libvlc_Playing || state == libvlc_Buffering )
 671     {
 672         if( libvlc_media_player_can_pause( p_mi, p_e ) )
 673             input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S );
 674         else
 675             libvlc_media_player_stop( p_mi, p_e );
 676     }
 677     else
 678         input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
 679
 680     vlc_object_release( p_input_thread );
 681 }
 682
 683 /**************************************************************************
 684  * Tells whether the media player is currently playing.
 685  *
 686  * Enter with lock held.
 687  **************************************************************************/
 688 int libvlc_media_player_is_playing( libvlc_media_player_t *p_mi,
 689                                      libvlc_exception_t *p_e )
 690 {
 691     libvlc_state_t state = libvlc_media_player_get_state( p_mi, p_e );
 692     return (libvlc_Playing == state) || (libvlc_Buffering == state);
 693 }
 694
 695 /**************************************************************************
 696  * Stop playing.
 697  **************************************************************************/
 698 void libvlc_media_player_stop( libvlc_media_player_t *p_mi,
 699                                  libvlc_exception_t *p_e )
 700 {
 701     libvlc_state_t state = libvlc_media_player_get_state( p_mi, p_e );
 702
 703     if( state == libvlc_Playing ||
 704         state == libvlc_Paused ||
 705         state == libvlc_Buffering )
 706     {
 707         /* Send a stop notification event only if we are in playing,
 708          * buffering or paused states */
 709         libvlc_media_set_state( p_mi->p_md, libvlc_Ended, p_e );
 710
 711         /* Construct and send the event */
 712         libvlc_event_t event;
 713         event.type = libvlc_MediaPlayerStopped;
 714         libvlc_event_send( p_mi->p_event_manager, &event );
 715     }
 716
 717     if( p_mi->b_own_its_input_thread )
 718     {
 719         vlc_mutex_lock( &p_mi->object_lock );
 720         release_input_thread( p_mi, true ); /* This will stop the input thread */
 721         vlc_mutex_unlock( &p_mi->object_lock );
 722     }
 723     else
 724     {
 725         input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 726         if( !p_input_thread )
 727             return;
 728
 729         input_Stop( p_input_thread, true );
 730         vlc_object_release( p_input_thread );
 731         p_mi->p_input_thread = NULL;
 732     }
 733 }
 734
 735 /**************************************************************************
 736  * set_nsobject
 737  **************************************************************************/
 738 void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi,
 739                                         void * drawable,
 740                                         libvlc_exception_t *p_e )
 741 {
 742     (void) p_e;
 743     p_mi->drawable.nsobject = drawable;
 744 }
 745
 746 /**************************************************************************
 747  * get_nsobject
 748  **************************************************************************/
 749 uint32_t libvlc_media_player_get_nsobject( libvlc_media_player_t *p_mi )
 750 {
 751     return p_mi->drawable.nsobject;
 752 }
 753
 754 /**************************************************************************
 755  * set_agl
 756  **************************************************************************/
 757 void libvlc_media_player_set_agl( libvlc_media_player_t *p_mi,
 758                                       uint32_t drawable,
 759                                       libvlc_exception_t *p_e )
 760 {
 761     (void) p_e;
 762     p_mi->drawable.agl = drawable;
 763 }
 764
 765 /**************************************************************************
 766  * get_agl
 767  **************************************************************************/
 768 uint32_t libvlc_media_player_get_agl( libvlc_media_player_t *p_mi )
 769 {
 770     return p_mi->drawable.agl;
 771 }
 772
 773 /**************************************************************************
 774  * set_xwindow
 775  **************************************************************************/
 776 void libvlc_media_player_set_xwindow( libvlc_media_player_t *p_mi,
 777                                       uint32_t drawable,
 778                                       libvlc_exception_t *p_e )
 779 {
 780     (void) p_e;
 781     p_mi->drawable.xid = drawable;
 782 }
 783
 784 /**************************************************************************
 785  * get_xwindow
 786  **************************************************************************/
 787 uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t *p_mi )
 788 {
 789     return p_mi->drawable.xid;
 790 }
 791
 792 /**************************************************************************
 793  * set_hwnd
 794  **************************************************************************/
 795 void libvlc_media_player_set_hwnd( libvlc_media_player_t *p_mi,
 796                                    void *drawable,
 797                                    libvlc_exception_t *p_e )
 798 {
 799     (void) p_e;
 800     p_mi->drawable.hwnd = drawable;
 801 }
 802
 803 /**************************************************************************
 804  * get_hwnd
 805  **************************************************************************/
 806 void *libvlc_media_player_get_hwnd( libvlc_media_player_t *p_mi )
 807 {
 808     return p_mi->drawable.hwnd;
 809 }
 810
 811 /**************************************************************************
 812  * Set Drawable
 813  **************************************************************************/
 814 void libvlc_media_player_set_drawable( libvlc_media_player_t *p_mi,
 815                                        libvlc_drawable_t drawable,
 816                                        libvlc_exception_t *p_e )
 817 {
 818 #ifdef WIN32
 819     if (sizeof (HWND) <= sizeof (libvlc_drawable_t))
 820         p_mi->drawable.hwnd = (HWND)drawable;
 821     else
 822         libvlc_exception_raise(p_e, "Operation not supported");
 823 #elif defined(__APPLE__)
 824     p_mi->drawable.agl = drawable;
 825     (void) p_e;
 826 #else
 827     p_mi->drawable.xid = drawable;
 828     (void) p_e;
 829 #endif
 830 }
 831
 832 /**************************************************************************
 833  * Get Drawable
 834  **************************************************************************/
 835 libvlc_drawable_t
 836 libvlc_media_player_get_drawable ( libvlc_media_player_t *p_mi,
 837                                    libvlc_exception_t *p_e )
 838 {
 839     VLC_UNUSED(p_e);
 840
 841 #ifdef WIN32
 842     if (sizeof (HWND) <= sizeof (libvlc_drawable_t))
 843         return (libvlc_drawable_t)p_mi->drawable.hwnd;
 844     else
 845         return 0;
 846 #elif defined(__APPLE__)
 847     return p_mi->drawable.agl;
 848 #else
 849     return p_mi->drawable.xid;
 850 #endif
 851 }
 852
 853 /**************************************************************************
 854  * Getters for stream information
 855  **************************************************************************/
 856 libvlc_time_t libvlc_media_player_get_length(
 857                              libvlc_media_player_t *p_mi,
 858                              libvlc_exception_t *p_e )
 859 {
 860     input_thread_t *p_input_thread;
 861     vlc_value_t val;
 862
 863     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 864     if( !p_input_thread )
 865         return -1;
 866
 867     var_Get( p_input_thread, "length", &val );
 868     vlc_object_release( p_input_thread );
 869
 870     return (val.i_time+500LL)/1000LL;
 871 }
 872
 873 libvlc_time_t libvlc_media_player_get_time(
 874                                    libvlc_media_player_t *p_mi,
 875                                    libvlc_exception_t *p_e )
 876 {
 877     input_thread_t *p_input_thread;
 878     vlc_value_t val;
 879
 880     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 881     if( !p_input_thread )
 882         return -1;
 883
 884     var_Get( p_input_thread , "time", &val );
 885     vlc_object_release( p_input_thread );
 886     return (val.i_time+500LL)/1000LL;
 887 }
 888
 889 void libvlc_media_player_set_time(
 890                                  libvlc_media_player_t *p_mi,
 891                                  libvlc_time_t time,
 892                                  libvlc_exception_t *p_e )
 893 {
 894     input_thread_t *p_input_thread;
 895
 896     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 897     if( !p_input_thread )
 898         return;
 899
 900     var_SetTime( p_input_thread, "time", time*1000LL );
 901     vlc_object_release( p_input_thread );
 902 }
 903
 904 void libvlc_media_player_set_position(
 905                                 libvlc_media_player_t *p_mi,
 906                                 float position,
 907                                 libvlc_exception_t *p_e )
 908 {
 909     input_thread_t *p_input_thread;
 910
 911     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 912     if( !p_input_thread )
 913         return;
 914
 915     var_SetFloat( p_input_thread, "position", position );
 916     vlc_object_release( p_input_thread );
 917 }
 918
 919 float libvlc_media_player_get_position(
 920                                  libvlc_media_player_t *p_mi,
 921                                  libvlc_exception_t *p_e )
 922 {
 923     input_thread_t *p_input_thread;
 924     vlc_value_t val;
 925
 926     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 927     if( !p_input_thread )
 928         return -1.0;
 929
 930     var_Get( p_input_thread, "position", &val );
 931     vlc_object_release( p_input_thread );
 932
 933     return val.f_float;
 934 }
 935
 936 void libvlc_media_player_set_chapter(
 937                                  libvlc_media_player_t *p_mi,
 938                                  int chapter,
 939                                  libvlc_exception_t *p_e )
 940 {
 941     input_thread_t *p_input_thread;
 942
 943     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
 944     if( !p_input_thread )
 945         return;
 946
 947     var_SetInteger( p_input_thread, "chapter", chapter );
 948     vlc_object_release( p_input_thread );
 949 }
 950
 951 int libvlc_media_player_get_chapter(
 952                                  libvlc_media_player_t *p_mi,
 953                                  libvlc_exception_t *p_e )
 954 {
 955     input_thread_t *p_input_thread;
 956     vlc_value_t val;
 957
 958     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 959     if( !p_input_thread )
 960         return -1;
 961
 962     var_Get( p_input_thread, "chapter", &val );
 963     vlc_object_release( p_input_thread );
 964
 965     return val.i_int;
 966 }
 967
 968 int libvlc_media_player_get_chapter_count(
 969                                  libvlc_media_player_t *p_mi,
 970                                  libvlc_exception_t *p_e )
 971 {
 972     input_thread_t *p_input_thread;
 973     vlc_value_t val;
 974
 975     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 976     if( !p_input_thread )
 977         return -1;
 978
 979     var_Change( p_input_thread, "chapter", VLC_VAR_CHOICESCOUNT, &val, NULL );
 980     vlc_object_release( p_input_thread );
 981
 982     return val.i_int;
 983 }
 984
 985 int libvlc_media_player_get_chapter_count_for_title(
 986                                  libvlc_media_player_t *p_mi,
 987                                  int i_title,
 988                                  libvlc_exception_t *p_e )
 989 {
 990     input_thread_t *p_input_thread;
 991     vlc_value_t val;
 992
 993     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 994     if( !p_input_thread )
 995         return -1;
 996
 997     char *psz_name;
 998     if( asprintf( &psz_name,  "title %2i", i_title ) == -1 )
 999     {
1000         vlc_object_release( p_input_thread );
1001         return -1;
1002     }
1003     var_Change( p_input_thread, psz_name, VLC_VAR_CHOICESCOUNT, &val, NULL );
1004     vlc_object_release( p_input_thread );
1005     free( psz_name );
1006
1007     return val.i_int;
1008 }
1009
1010 void libvlc_media_player_set_title(
1011                                  libvlc_media_player_t *p_mi,
1012                                  int i_title,
1013                                  libvlc_exception_t *p_e )
1014 {
1015     input_thread_t *p_input_thread;
1016
1017     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
1018     if( !p_input_thread )
1019         return;
1020
1021     var_SetInteger( p_input_thread, "title", i_title );
1022     vlc_object_release( p_input_thread );
1023
1024     //send event
1025     libvlc_event_t event;
1026     event.type = libvlc_MediaPlayerTitleChanged;
1027     event.u.media_player_title_changed.new_title = i_title;
1028     libvlc_event_send( p_mi->p_event_manager, &event );
1029 }
1030
1031 int libvlc_media_player_get_title(
1032                                  libvlc_media_player_t *p_mi,
1033                                  libvlc_exception_t *p_e )
1034 {
1035     input_thread_t *p_input_thread;
1036     vlc_value_t val;
1037
1038     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1039     if( !p_input_thread )
1040         return -1;
1041
1042     var_Get( p_input_thread, "title", &val );
1043     vlc_object_release( p_input_thread );
1044
1045     return val.i_int;
1046 }
1047
1048 int libvlc_media_player_get_title_count(
1049                                  libvlc_media_player_t *p_mi,
1050                                  libvlc_exception_t *p_e )
1051 {
1052     input_thread_t *p_input_thread;
1053     vlc_value_t val;
1054
1055     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1056     if( !p_input_thread )
1057         return -1;
1058
1059     var_Change( p_input_thread, "title", VLC_VAR_CHOICESCOUNT, &val, NULL );
1060     vlc_object_release( p_input_thread );
1061
1062     return val.i_int;
1063 }
1064
1065 void libvlc_media_player_next_chapter(
1066                                  libvlc_media_player_t *p_mi,
1067                                  libvlc_exception_t *p_e )
1068 {
1069     input_thread_t *p_input_thread;
1070
1071     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
1072     if( !p_input_thread )
1073         return;
1074
1075     int i_type = var_Type( p_input_thread, "next-chapter" );
1076     var_SetBool( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
1077                             "next-chapter":"next-title", true );
1078
1079     vlc_object_release( p_input_thread );
1080 }
1081
1082 void libvlc_media_player_previous_chapter(
1083                                  libvlc_media_player_t *p_mi,
1084                                  libvlc_exception_t *p_e )
1085 {
1086     input_thread_t *p_input_thread;
1087
1088     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
1089     if( !p_input_thread )
1090         return;
1091
1092     int i_type = var_Type( p_input_thread, "next-chapter" );
1093     var_SetBool( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
1094                             "prev-chapter":"prev-title", true );
1095
1096     vlc_object_release( p_input_thread );
1097 }
1098
1099 float libvlc_media_player_get_fps(
1100                                  libvlc_media_player_t *p_mi,
1101                                  libvlc_exception_t *p_e)
1102 {
1103     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1104     double f_fps = 0.0;
1105
1106     if( p_input_thread )
1107     {
1108         if( input_Control( p_input_thread, INPUT_GET_VIDEO_FPS, &f_fps ) )
1109             f_fps = 0.0;
1110         vlc_object_release( p_input_thread );
1111     }
1112     return f_fps;
1113 }
1114
1115 int libvlc_media_player_will_play( libvlc_media_player_t *p_mi,
1116                                      libvlc_exception_t *p_e)
1117 {
1118     input_thread_t *p_input_thread =
1119                             libvlc_get_input_thread ( p_mi, p_e);
1120     if ( !p_input_thread )
1121         return false;
1122
1123     if ( !p_input_thread->b_die && !p_input_thread->b_dead )
1124     {
1125         vlc_object_release( p_input_thread );
1126         return true;
1127     }
1128     vlc_object_release( p_input_thread );
1129     return false;
1130 }
1131
1132 void libvlc_media_player_set_rate(
1133                                  libvlc_media_player_t *p_mi,
1134                                  float rate,
1135                                  libvlc_exception_t *p_e )
1136 {
1137     input_thread_t *p_input_thread;
1138     bool b_can_rewind;
1139
1140     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1141     if( !p_input_thread )
1142         return;
1143
1144     b_can_rewind = var_GetBool( p_input_thread, "can-rewind" );
1145     if( (rate < 0.0) && !b_can_rewind )
1146     {
1147         vlc_object_release( p_input_thread );
1148         libvlc_exception_raise( p_e, "Rate value is invalid" );
1149         return;
1150     }
1151
1152     var_SetInteger( p_input_thread, "rate", 1000.0f/rate );
1153     vlc_object_release( p_input_thread );
1154 }
1155
1156 float libvlc_media_player_get_rate(
1157                                  libvlc_media_player_t *p_mi,
1158                                  libvlc_exception_t *p_e )
1159 {
1160     input_thread_t *p_input_thread;
1161     vlc_value_t val;
1162     bool b_can_rewind;
1163
1164     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1165     if( !p_input_thread )
1166         return 0.0;  /* rate < 0 indicates rewind */
1167
1168     var_Get( p_input_thread, "rate", &val );
1169     b_can_rewind = var_GetBool( p_input_thread, "can-rewind" );
1170     if( (val.i_int < 0) && !b_can_rewind )
1171     {
1172         libvlc_exception_raise( p_e, "invalid rate" );
1173         return 0.0;
1174     }
1175     vlc_object_release( p_input_thread );
1176
1177     return (float)1000.0f/val.i_int;
1178 }
1179
1180 libvlc_state_t libvlc_media_player_get_state(
1181                                  libvlc_media_player_t *p_mi,
1182                                  libvlc_exception_t *p_e )
1183 {
1184     input_thread_t *p_input_thread;
1185     libvlc_state_t state = libvlc_Ended;
1186     vlc_value_t val;
1187
1188     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1189     if( !p_input_thread )
1190     {
1191         /* We do return the right value, no need to throw an exception */
1192         if( libvlc_exception_raised( p_e ) )
1193             libvlc_exception_clear( p_e );
1194         return state;
1195     }
1196
1197     var_Get( p_input_thread, "state", &val );
1198     state = vlc_to_libvlc_state(val.i_int);
1199
1200     if( state == libvlc_Playing )
1201     {
1202         float caching;
1203         caching = var_GetFloat( p_input_thread, "cache" );
1204         if( caching > 0.0 && caching < 1.0 )
1205             state = libvlc_Buffering;
1206     }
1207     vlc_object_release( p_input_thread );
1208     return state;
1209 }
1210
1211 int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi,
1212                                        libvlc_exception_t *p_e )
1213 {
1214     input_thread_t *p_input_thread;
1215     vlc_value_t val;
1216
1217     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1218     if ( !p_input_thread )
1219     {
1220         /* We do return the right value, no need to throw an exception */
1221         if( libvlc_exception_raised( p_e ) )
1222             libvlc_exception_clear( p_e );
1223         return false;
1224     }
1225     var_Get( p_input_thread, "can-seek", &val );
1226     vlc_object_release( p_input_thread );
1227
1228     return val.b_bool;
1229 }
1230
1231 /* internal function, used by audio, video */
1232 libvlc_track_description_t *
1233         libvlc_get_track_description( libvlc_media_player_t *p_mi,
1234                                       const char *psz_variable,
1235                                       libvlc_exception_t *p_e )
1236 {
1237     input_thread_t *p_input = libvlc_get_input_thread( p_mi, p_e );
1238
1239     if( !p_input )
1240         return NULL;
1241
1242     vlc_value_t val_list, text_list;
1243     var_Change( p_input, psz_variable, VLC_VAR_GETLIST, &val_list, &text_list);
1244
1245     if( val_list.p_list->i_count <= 0 ) /* no tracks */
1246         return NULL;
1247
1248     libvlc_track_description_t *p_track_description, *p_actual, *p_previous;
1249     p_track_description = ( libvlc_track_description_t * )
1250         malloc( sizeof( libvlc_track_description_t ) );
1251     if ( !p_track_description )
1252     {
1253         var_Change( p_input, psz_variable, VLC_VAR_FREELIST,
1254                     &val_list, &text_list);
1255         vlc_object_release( p_input );
1256         libvlc_exception_raise( p_e, "no enough memory" );
1257         return NULL;
1258     }
1259     p_actual = p_track_description;
1260     p_previous = NULL;
1261     for( int i = 0; i < val_list.p_list->i_count; i++ )
1262     {
1263         if( !p_actual )
1264         {
1265             p_actual = ( libvlc_track_description_t * )
1266                 malloc( sizeof( libvlc_track_description_t ) );
1267             if ( !p_actual )
1268             {
1269                 libvlc_track_description_release( p_track_description );
1270                 var_Change( p_input, psz_variable, VLC_VAR_FREELIST,
1271                             &val_list, &text_list);
1272                 vlc_object_release( p_input );
1273                 libvlc_exception_raise( p_e, "no enough memory" );
1274                 return NULL;
1275             }
1276         }
1277         p_actual->i_id = val_list.p_list->p_values[i].i_int;
1278         p_actual->psz_name = strdup( text_list.p_list->p_values[i].psz_string );
1279         p_actual->p_next = NULL;
1280         if( p_previous )
1281             p_previous->p_next = p_actual;
1282         p_previous = p_actual;
1283         p_actual =  NULL;
1284     }
1285     var_Change( p_input, psz_variable, VLC_VAR_FREELIST, &val_list, &text_list);
1286     vlc_object_release( p_input );
1287
1288     return p_track_description;
1289 }
1290
1291 void libvlc_track_description_release( libvlc_track_description_t *p_td )
1292 {
1293     libvlc_track_description_t *p_actual, *p_before;
1294     p_actual = p_td;
1295
1296     while ( p_actual )
1297     {
1298         free( p_actual->psz_name );
1299         p_before = p_actual;
1300         p_actual = p_before->p_next;
1301         free( p_before );
1302     }
1303 }
1304
1305 int libvlc_media_player_can_pause( libvlc_media_player_t *p_mi,
1306                                      libvlc_exception_t *p_e )
1307 {
1308     input_thread_t *p_input_thread;
1309     vlc_value_t val;
1310
1311     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
1312     if ( !p_input_thread )
1313     {
1314         /* We do return the right value, no need to throw an exception */
1315         if( libvlc_exception_raised( p_e ) )
1316             libvlc_exception_clear( p_e );
1317         return false;
1318     }
1319     var_Get( p_input_thread, "can-pause", &val );
1320     vlc_object_release( p_input_thread );
1321
1322     return val.b_bool;
1323 }