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