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