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     /* Video */
 500     var_Create (mp, "drawable-xid", VLC_VAR_INTEGER);
 501 #ifdef WIN32
 502     var_Create (mp, "drawable-hwnd", VLC_VAR_ADDRESS);
 503 #endif
 504 #ifdef __APPLE__
 505     var_Create (mp, "drawable-agl", VLC_VAR_INTEGER);
 506     var_Create (mp, "drawable-nsobject", VLC_VAR_ADDRESS);
 507 #endif
 508
 509     var_Create (mp, "keyboard-events", VLC_VAR_BOOL);
 510     var_SetBool (mp, "keyboard-events", true);
 511     var_Create (mp, "mouse-events", VLC_VAR_BOOL);
 512     var_SetBool (mp, "mouse-events", true);
 513
 514     var_Create (mp, "fullscreen", VLC_VAR_BOOL);
 515     var_Create (mp, "autoscale", VLC_VAR_BOOL);
 516     var_SetBool (mp, "autoscale", true);
 517     var_Create (mp, "scale", VLC_VAR_FLOAT);
 518     var_SetFloat (mp, "scale", 1.);
 519     var_Create (mp, "aspect-ratio", VLC_VAR_STRING);
 520     var_Create (mp, "crop", VLC_VAR_STRING);
 521     var_Create (mp, "deinterlace", VLC_VAR_INTEGER);
 522     var_Create (mp, "deinterlace-mode", VLC_VAR_STRING);
 523
 524     var_Create (mp, "vbi-page", VLC_VAR_INTEGER);
 525
 526     var_Create (mp, "marq-marquee", VLC_VAR_STRING);
 527     var_Create (mp, "marq-color", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 528     var_Create (mp, "marq-opacity", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 529     var_Create (mp, "marq-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 530     var_Create (mp, "marq-refresh", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 531     var_Create (mp, "marq-size", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 532     var_Create (mp, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 533     var_Create (mp, "marq-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 534     var_Create (mp, "marq-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 535
 536     var_Create (mp, "logo-file", VLC_VAR_STRING);
 537     var_Create (mp, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 538     var_Create (mp, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 539     var_Create (mp, "logo-delay", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 540     var_Create (mp, "logo-repeat", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 541     var_Create (mp, "logo-opacity", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 542     var_Create (mp, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
 543
 544      /* Audio */
 545     var_Create (mp, "aout", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
 546     var_Create (mp, "find-input-callback", VLC_VAR_ADDRESS);
 547     var_SetAddress (mp, "find-input-callback", find_input);
 548
 549     mp->p_md = NULL;
 550     mp->state = libvlc_NothingSpecial;
 551     mp->p_libvlc_instance = instance;
 552     mp->p_input_thread = NULL;
 553     mp->p_input_resource = NULL;
 554     mp->p_vout_thread = NULL;
 555     mp->i_refcount = 1;
 556     mp->p_event_manager = libvlc_event_manager_new(mp, instance);
 557     if (unlikely(mp->p_event_manager == NULL))
 558     {
 559         vlc_object_release(mp);
 560         return NULL;
 561     }
 562     vlc_mutex_init(&mp->object_lock);
 563
 564     register_event(mp, NothingSpecial);
 565     register_event(mp, Opening);
 566     register_event(mp, Buffering);
 567     register_event(mp, Playing);
 568     register_event(mp, Paused);
 569     register_event(mp, Stopped);
 570     register_event(mp, Forward);
 571     register_event(mp, Backward);
 572     register_event(mp, EndReached);
 573     register_event(mp, EncounteredError);
 574     register_event(mp, SeekableChanged);
 575
 576     register_event(mp, PositionChanged);
 577     register_event(mp, TimeChanged);
 578     register_event(mp, LengthChanged);
 579     register_event(mp, TitleChanged);
 580     register_event(mp, PausableChanged);
 581
 582     /* Snapshot initialization */
 583     register_event(mp, SnapshotTaken);
 584
 585     register_event(mp, MediaChanged);
 586
 587     /* mouse events */
 588     register_event(mp, MouseMoved);
 589     register_event(mp, MouseButton);
 590     register_event(mp, MouseClick);
 591     register_event(mp, MouseObject);
 592
 593     /* Attach a var callback to the global object to provide the glue between
 594      * vout_thread that generates the event and media_player that re-emits it
 595      * with its own event manager
 596      *
 597      * FIXME: It's unclear why we want to put this in public API, and why we
 598      * want to expose it in such a limiting and ugly way.
 599      */
 600     var_AddCallback(mp->p_libvlc, "snapshot-file", snapshot_was_taken, mp);
 601
 602     libvlc_retain(instance);
 603     return mp;
 604 }
 605
 606 /**************************************************************************
 607  * Create a Media Instance object with a media descriptor.
 608  **************************************************************************/
 609 libvlc_media_player_t *
 610 libvlc_media_player_new_from_media( libvlc_media_t * p_md )
 611 {
 612     libvlc_media_player_t * p_mi;
 613
 614     p_mi = libvlc_media_player_new( p_md->p_libvlc_instance );
 615     if( !p_mi )
 616         return NULL;
 617
 618     libvlc_media_retain( p_md );
 619     p_mi->p_md = p_md;
 620
 621     return p_mi;
 622 }
 623
 624 /**************************************************************************
 625  * Destroy a Media Instance object (libvlc internal)
 626  *
 627  * Warning: No lock held here, but hey, this is internal. Caller must lock.
 628  **************************************************************************/
 629 static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi )
 630 {
 631     assert( p_mi );
 632
 633     /* Detach Callback from the main libvlc object */
 634     var_DelCallback( p_mi->p_libvlc,
 635                      "snapshot-file", snapshot_was_taken, p_mi );
 636
 637     /* If the input thread hasn't been already deleted it means
 638      * that the owners didn't stop the thread before releasing it. */
 639     assert(!p_mi->p_input_thread);
 640
 641     /* Fallback for those who don't use NDEBUG */
 642     if( p_mi->p_vout_thread )
 643         release_vout_thread( p_mi );
 644
 645     if(p_mi->p_input_thread )
 646         release_input_thread(p_mi, true);
 647
 648     if( p_mi->p_input_resource )
 649     {
 650         input_resource_Delete( p_mi->p_input_resource );
 651         p_mi->p_input_resource = NULL;
 652     }
 653
 654     libvlc_event_manager_release( p_mi->p_event_manager );
 655     libvlc_media_release( p_mi->p_md );
 656     vlc_mutex_destroy( &p_mi->object_lock );
 657
 658     libvlc_instance_t *instance = p_mi->p_libvlc_instance;
 659     vlc_object_release( p_mi );
 660     libvlc_release(instance);
 661 }
 662
 663 /**************************************************************************
 664  * Release a Media Instance object.
 665  *
 666  * Function does the locking.
 667  **************************************************************************/
 668 void libvlc_media_player_release( libvlc_media_player_t *p_mi )
 669 {
 670     bool destroy;
 671
 672     assert( p_mi );
 673     lock(p_mi);
 674     destroy = !--p_mi->i_refcount;
 675     unlock(p_mi);
 676
 677     if( destroy )
 678         libvlc_media_player_destroy( p_mi );
 679 }
 680
 681 /**************************************************************************
 682  * Retain a Media Instance object.
 683  *
 684  * Caller must hold the lock.
 685  **************************************************************************/
 686 void libvlc_media_player_retain( libvlc_media_player_t *p_mi )
 687 {
 688     assert( p_mi );
 689
 690     lock(p_mi);
 691     p_mi->i_refcount++;
 692     unlock(p_mi);
 693 }
 694
 695 /**************************************************************************
 696  * Set the Media descriptor associated with the instance.
 697  *
 698  * Enter without lock -- function will lock the object.
 699  **************************************************************************/
 700 void libvlc_media_player_set_media(
 701                             libvlc_media_player_t *p_mi,
 702                             libvlc_media_t *p_md )
 703 {
 704     lock(p_mi);
 705
 706     /* FIXME I am not sure if it is a user request or on die(eof/error)
 707      * request here */
 708     release_input_thread( p_mi,
 709                           p_mi->p_input_thread &&
 710                           !p_mi->p_input_thread->b_eof &&
 711                           !p_mi->p_input_thread->b_error );
 712
 713     set_state( p_mi, libvlc_NothingSpecial, true );
 714
 715     libvlc_media_release( p_mi->p_md );
 716
 717     if( !p_md )
 718     {
 719         p_mi->p_md = NULL;
 720         unlock(p_mi);
 721         return; /* It is ok to pass a NULL md */
 722     }
 723
 724     libvlc_media_retain( p_md );
 725     p_mi->p_md = p_md;
 726
 727     /* The policy here is to ignore that we were created using a different
 728      * libvlc_instance, because we don't really care */
 729     p_mi->p_libvlc_instance = p_md->p_libvlc_instance;
 730
 731     unlock(p_mi);
 732
 733     /* Send an event for the newly available media */
 734     libvlc_event_t event;
 735     event.type = libvlc_MediaPlayerMediaChanged;
 736     event.u.media_player_media_changed.new_media = p_md;
 737     libvlc_event_send( p_mi->p_event_manager, &event );
 738
 739 }
 740
 741 /**************************************************************************
 742  * Get the Media descriptor associated with the instance.
 743  **************************************************************************/
 744 libvlc_media_t *
 745 libvlc_media_player_get_media( libvlc_media_player_t *p_mi )
 746 {
 747     libvlc_media_t *p_m;
 748
 749     lock(p_mi);
 750     p_m = p_mi->p_md;
 751     if( p_m )
 752         libvlc_media_retain( p_mi->p_md );
 753     unlock(p_mi);
 754     return p_mi->p_md;
 755 }
 756
 757 /**************************************************************************
 758  * Get the event Manager.
 759  **************************************************************************/
 760 libvlc_event_manager_t *
 761 libvlc_media_player_event_manager( libvlc_media_player_t *p_mi )
 762 {
 763     return p_mi->p_event_manager;
 764 }
 765
 766 /**************************************************************************
 767  * Tell media player to start playing.
 768  **************************************************************************/
 769 int libvlc_media_player_play( libvlc_media_player_t *p_mi )
 770 {
 771     input_thread_t * p_input_thread;
 772
 773     if( (p_input_thread = libvlc_get_input_thread( p_mi )) )
 774     {
 775         /* A thread already exists, send it a play message */
 776         input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
 777         vlc_object_release( p_input_thread );
 778         return 0;
 779     }
 780
 781     /* Ignore previous exception */
 782     lock(p_mi);
 783
 784     if( !p_mi->p_md )
 785     {
 786         unlock(p_mi);
 787         libvlc_printerr( "No associated media descriptor" );
 788         return -1;
 789     }
 790
 791     p_mi->p_input_thread = input_Create( p_mi,
 792                                          p_mi->p_md->p_input_item, NULL,
 793                                          p_mi->p_input_resource );
 794     if( !p_mi->p_input_thread )
 795     {
 796         unlock(p_mi);
 797         libvlc_printerr( "Not enough memory" );
 798         return -1;
 799     }
 800
 801     p_mi->p_input_resource = NULL;
 802     p_input_thread = p_mi->p_input_thread;
 803
 804     var_AddCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi );
 805     var_AddCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi );
 806     var_AddCallback( p_input_thread, "intf-event", input_event_changed, p_mi );
 807
 808     if( input_Start( p_input_thread ) )
 809     {
 810         vlc_object_release( p_input_thread );
 811         p_mi->p_input_thread = NULL;
 812     }
 813
 814     unlock(p_mi);
 815     return 0;
 816 }
 817
 818 /**************************************************************************
 819  * Pause.
 820  **************************************************************************/
 821 void libvlc_media_player_pause( libvlc_media_player_t *p_mi )
 822 {
 823     input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi );
 824     if( !p_input_thread )
 825         return;
 826
 827     libvlc_state_t state = libvlc_media_player_get_state( p_mi );
 828     if( state == libvlc_Playing || state == libvlc_Buffering )
 829     {
 830         if( libvlc_media_player_can_pause( p_mi ) )
 831             input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S );
 832         else
 833             libvlc_media_player_stop( p_mi );
 834     }
 835     else
 836         input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
 837
 838     vlc_object_release( p_input_thread );
 839 }
 840
 841 /**************************************************************************
 842  * Tells whether the media player is currently playing.
 843  *
 844  * Enter with lock held.
 845  **************************************************************************/
 846 int libvlc_media_player_is_playing( libvlc_media_player_t *p_mi )
 847 {
 848     libvlc_state_t state = libvlc_media_player_get_state( p_mi );
 849     return (libvlc_Playing == state) || (libvlc_Buffering == state);
 850 }
 851
 852 /**************************************************************************
 853  * Stop playing.
 854  **************************************************************************/
 855 void libvlc_media_player_stop( libvlc_media_player_t *p_mi )
 856 {
 857     libvlc_state_t state = libvlc_media_player_get_state( p_mi );
 858
 859     lock(p_mi);
 860     release_input_thread( p_mi, true ); /* This will stop the input thread */
 861     unlock(p_mi);
 862
 863     /* Force to go to stopped state, in case we were in Ended, or Error
 864      * state. */
 865     if( state != libvlc_Stopped )
 866     {
 867         set_state( p_mi, libvlc_Stopped, false );
 868
 869         /* Construct and send the event */
 870         libvlc_event_t event;
 871         event.type = libvlc_MediaPlayerStopped;
 872         libvlc_event_send( p_mi->p_event_manager, &event );
 873     }
 874 }
 875
 876 /**************************************************************************
 877  * set_nsobject
 878  **************************************************************************/
 879 void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi,
 880                                         void * drawable )
 881 {
 882     assert (p_mi != NULL);
 883 #ifdef __APPLE__
 884     var_SetAddress (p_mi, "drawable-nsobject", drawable);
 885 #else
 886     (void) p_mi; (void)drawable;
 887 #endif
 888 }
 889
 890 /**************************************************************************
 891  * get_nsobject
 892  **************************************************************************/
 893 void * libvlc_media_player_get_nsobject( libvlc_media_player_t *p_mi )
 894 {
 895     assert (p_mi != NULL);
 896 #ifdef __APPLE__
 897     return var_GetAddress (p_mi, "drawable-nsobject");
 898 #else
 899     return NULL;
 900 #endif
 901 }
 902
 903 /**************************************************************************
 904  * set_agl
 905  **************************************************************************/
 906 void libvlc_media_player_set_agl( libvlc_media_player_t *p_mi,
 907                                   uint32_t drawable )
 908 {
 909 #ifdef __APPLE__
 910     var_SetInteger (p_mi, "drawable-agl", drawable);
 911 #else
 912     (void) p_mi; (void)drawable;
 913 #endif
 914 }
 915
 916 /**************************************************************************
 917  * get_agl
 918  **************************************************************************/
 919 uint32_t libvlc_media_player_get_agl( libvlc_media_player_t *p_mi )
 920 {
 921     assert (p_mi != NULL);
 922 #ifdef __APPLE__
 923     return var_GetInteger (p_mi, "drawable-agl");
 924 #else
 925     return 0;
 926 #endif
 927 }
 928
 929 /**************************************************************************
 930  * set_xwindow
 931  **************************************************************************/
 932 void libvlc_media_player_set_xwindow( libvlc_media_player_t *p_mi,
 933                                       uint32_t drawable )
 934 {
 935     assert (p_mi != NULL);
 936     var_SetInteger (p_mi, "drawable-xid", drawable);
 937 }
 938
 939 /**************************************************************************
 940  * get_xwindow
 941  **************************************************************************/
 942 uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t *p_mi )
 943 {
 944     return var_GetInteger (p_mi, "drawable-xid");
 945 }
 946
 947 /**************************************************************************
 948  * set_hwnd
 949  **************************************************************************/
 950 void libvlc_media_player_set_hwnd( libvlc_media_player_t *p_mi,
 951                                    void *drawable )
 952 {
 953     assert (p_mi != NULL);
 954 #ifdef WIN32
 955     var_SetAddress (p_mi, "drawable-hwnd", drawable);
 956 #else
 957     (void) p_mi; (void) drawable;
 958 #endif
 959 }
 960
 961 /**************************************************************************
 962  * get_hwnd
 963  **************************************************************************/
 964 void *libvlc_media_player_get_hwnd( libvlc_media_player_t *p_mi )
 965 {
 966     assert (p_mi != NULL);
 967 #ifdef WIN32
 968     return var_GetAddress (p_mi, "drawable-hwnd");
 969 #else
 970     return NULL;
 971 #endif
 972 }
 973
 974 /**************************************************************************
 975  * Getters for stream information
 976  **************************************************************************/
 977 libvlc_time_t libvlc_media_player_get_length(
 978                              libvlc_media_player_t *p_mi )
 979 {
 980     input_thread_t *p_input_thread;
 981     libvlc_time_t i_time;
 982
 983     p_input_thread = libvlc_get_input_thread ( p_mi );
 984     if( !p_input_thread )
 985         return -1;
 986
 987     i_time = from_mtime(var_GetTime( p_input_thread, "length" ));
 988     vlc_object_release( p_input_thread );
 989
 990     return i_time;
 991 }
 992
 993 libvlc_time_t libvlc_media_player_get_time( libvlc_media_player_t *p_mi )
 994 {
 995     input_thread_t *p_input_thread;
 996     libvlc_time_t i_time;
 997
 998     p_input_thread = libvlc_get_input_thread ( p_mi );
 999     if( !p_input_thread )
1000         return -1;
1001
1002     i_time = from_mtime(var_GetTime( p_input_thread , "time" ));
1003     vlc_object_release( p_input_thread );
1004     return i_time;
1005 }
1006
1007 void libvlc_media_player_set_time( libvlc_media_player_t *p_mi,
1008                                    libvlc_time_t i_time )
1009 {
1010     input_thread_t *p_input_thread;
1011
1012     p_input_thread = libvlc_get_input_thread ( p_mi );
1013     if( !p_input_thread )
1014         return;
1015
1016     var_SetTime( p_input_thread, "time", to_mtime(i_time) );
1017     vlc_object_release( p_input_thread );
1018 }
1019
1020 void libvlc_media_player_set_position( libvlc_media_player_t *p_mi,
1021                                        float position )
1022 {
1023     input_thread_t *p_input_thread;
1024
1025     p_input_thread = libvlc_get_input_thread ( p_mi );
1026     if( !p_input_thread )
1027         return;
1028
1029     var_SetFloat( p_input_thread, "position", position );
1030     vlc_object_release( p_input_thread );
1031 }
1032
1033 float libvlc_media_player_get_position( libvlc_media_player_t *p_mi )
1034 {
1035     input_thread_t *p_input_thread;
1036     float f_position;
1037
1038     p_input_thread = libvlc_get_input_thread ( p_mi );
1039     if( !p_input_thread )
1040         return -1.0;
1041
1042     f_position = var_GetFloat( p_input_thread, "position" );
1043     vlc_object_release( p_input_thread );
1044
1045     return f_position;
1046 }
1047
1048 void libvlc_media_player_set_chapter( libvlc_media_player_t *p_mi,
1049                                       int chapter )
1050 {
1051     input_thread_t *p_input_thread;
1052
1053     p_input_thread = libvlc_get_input_thread ( p_mi );
1054     if( !p_input_thread )
1055         return;
1056
1057     var_SetInteger( p_input_thread, "chapter", chapter );
1058     vlc_object_release( p_input_thread );
1059 }
1060
1061 int libvlc_media_player_get_chapter( libvlc_media_player_t *p_mi )
1062 {
1063     input_thread_t *p_input_thread;
1064     int i_chapter;
1065
1066     p_input_thread = libvlc_get_input_thread ( p_mi );
1067     if( !p_input_thread )
1068         return -1;
1069
1070     i_chapter = var_GetInteger( p_input_thread, "chapter" );
1071     vlc_object_release( p_input_thread );
1072
1073     return i_chapter;
1074 }
1075
1076 int libvlc_media_player_get_chapter_count( libvlc_media_player_t *p_mi )
1077 {
1078     input_thread_t *p_input_thread;
1079     vlc_value_t val;
1080
1081     p_input_thread = libvlc_get_input_thread ( p_mi );
1082     if( !p_input_thread )
1083         return -1;
1084
1085     var_Change( p_input_thread, "chapter", VLC_VAR_CHOICESCOUNT, &val, NULL );
1086     vlc_object_release( p_input_thread );
1087
1088     return val.i_int;
1089 }
1090
1091 int libvlc_media_player_get_chapter_count_for_title(
1092                                  libvlc_media_player_t *p_mi,
1093                                  int i_title )
1094 {
1095     input_thread_t *p_input_thread;
1096     vlc_value_t val;
1097
1098     p_input_thread = libvlc_get_input_thread ( p_mi );
1099     if( !p_input_thread )
1100         return -1;
1101
1102     char *psz_name;
1103     if( asprintf( &psz_name,  "title %2i", i_title ) == -1 )
1104     {
1105         vlc_object_release( p_input_thread );
1106         return -1;
1107     }
1108     var_Change( p_input_thread, psz_name, VLC_VAR_CHOICESCOUNT, &val, NULL );
1109     vlc_object_release( p_input_thread );
1110     free( psz_name );
1111
1112     return val.i_int;
1113 }
1114
1115 void libvlc_media_player_set_title( libvlc_media_player_t *p_mi,
1116                                     int i_title )
1117 {
1118     input_thread_t *p_input_thread;
1119
1120     p_input_thread = libvlc_get_input_thread ( p_mi );
1121     if( !p_input_thread )
1122         return;
1123
1124     var_SetInteger( p_input_thread, "title", i_title );
1125     vlc_object_release( p_input_thread );
1126
1127     //send event
1128     libvlc_event_t event;
1129     event.type = libvlc_MediaPlayerTitleChanged;
1130     event.u.media_player_title_changed.new_title = i_title;
1131     libvlc_event_send( p_mi->p_event_manager, &event );
1132 }
1133
1134 int libvlc_media_player_get_title( libvlc_media_player_t *p_mi )
1135 {
1136     input_thread_t *p_input_thread;
1137     int i_title;
1138
1139     p_input_thread = libvlc_get_input_thread ( p_mi );
1140     if( !p_input_thread )
1141         return -1;
1142
1143     i_title = var_GetInteger( p_input_thread, "title" );
1144     vlc_object_release( p_input_thread );
1145
1146     return i_title;
1147 }
1148
1149 int libvlc_media_player_get_title_count( libvlc_media_player_t *p_mi )
1150 {
1151     input_thread_t *p_input_thread;
1152     vlc_value_t val;
1153
1154     p_input_thread = libvlc_get_input_thread ( p_mi );
1155     if( !p_input_thread )
1156         return -1;
1157
1158     var_Change( p_input_thread, "title", VLC_VAR_CHOICESCOUNT, &val, NULL );
1159     vlc_object_release( p_input_thread );
1160
1161     return val.i_int;
1162 }
1163
1164 void libvlc_media_player_next_chapter( libvlc_media_player_t *p_mi )
1165 {
1166     input_thread_t *p_input_thread;
1167
1168     p_input_thread = libvlc_get_input_thread ( p_mi );
1169     if( !p_input_thread )
1170         return;
1171
1172     int i_type = var_Type( p_input_thread, "next-chapter" );
1173     var_SetBool( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
1174                             "next-chapter":"next-title", true );
1175
1176     vlc_object_release( p_input_thread );
1177 }
1178
1179 void libvlc_media_player_previous_chapter( libvlc_media_player_t *p_mi )
1180 {
1181     input_thread_t *p_input_thread;
1182
1183     p_input_thread = libvlc_get_input_thread ( p_mi );
1184     if( !p_input_thread )
1185         return;
1186
1187     int i_type = var_Type( p_input_thread, "next-chapter" );
1188     var_SetBool( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
1189                             "prev-chapter":"prev-title", true );
1190
1191     vlc_object_release( p_input_thread );
1192 }
1193
1194 float libvlc_media_player_get_fps( libvlc_media_player_t *p_mi )
1195 {
1196     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
1197     double f_fps = 0.0;
1198
1199     if( p_input_thread )
1200     {
1201         if( input_Control( p_input_thread, INPUT_GET_VIDEO_FPS, &f_fps ) )
1202             f_fps = 0.0;
1203         vlc_object_release( p_input_thread );
1204     }
1205     return f_fps;
1206 }
1207
1208 int libvlc_media_player_will_play( libvlc_media_player_t *p_mi )
1209 {
1210     bool b_will_play;
1211     input_thread_t *p_input_thread =
1212                             libvlc_get_input_thread ( p_mi );
1213     if ( !p_input_thread )
1214         return false;
1215
1216     b_will_play = !p_input_thread->b_die && !p_input_thread->b_dead;
1217     vlc_object_release( p_input_thread );
1218
1219     return b_will_play;
1220 }
1221
1222 int libvlc_media_player_set_rate( libvlc_media_player_t *p_mi, float rate )
1223 {
1224     input_thread_t *p_input_thread;
1225     bool b_can_rewind;
1226
1227     p_input_thread = libvlc_get_input_thread ( p_mi );
1228     if( !p_input_thread )
1229         return -1;
1230
1231     b_can_rewind = var_GetBool( p_input_thread, "can-rewind" );
1232     if( (rate < 0.0) && !b_can_rewind )
1233     {
1234         vlc_object_release( p_input_thread );
1235         libvlc_printerr( "Invalid playback rate" );
1236         return -1;
1237     }
1238
1239     var_SetFloat( p_input_thread, "rate", rate );
1240     vlc_object_release( p_input_thread );
1241     return 0;
1242 }
1243
1244 float libvlc_media_player_get_rate( libvlc_media_player_t *p_mi )
1245 {
1246     input_thread_t *p_input_thread;
1247     float f_rate;
1248     bool b_can_rewind;
1249
1250     p_input_thread = libvlc_get_input_thread ( p_mi );
1251     if( !p_input_thread )
1252         return 0.0;  /* rate < 0 indicates rewind */
1253
1254     f_rate = var_GetFloat( p_input_thread, "rate" );
1255     b_can_rewind = var_GetBool( p_input_thread, "can-rewind" );
1256     /* FIXME: why are negative values forbidden ?? (rewinding) */
1257     if( f_rate < 0 && !b_can_rewind )
1258     {
1259         vlc_object_release( p_input_thread );
1260         return 0.0;
1261     }
1262     vlc_object_release( p_input_thread );
1263
1264     return f_rate;
1265 }
1266
1267 libvlc_state_t libvlc_media_player_get_state( libvlc_media_player_t *p_mi )
1268 {
1269     lock(p_mi);
1270     libvlc_state_t state = p_mi->state;
1271     unlock(p_mi);
1272     return state;
1273 }
1274
1275 int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi )
1276 {
1277     input_thread_t *p_input_thread;
1278     bool b_seekable;
1279
1280     p_input_thread = libvlc_get_input_thread ( p_mi );
1281     if ( !p_input_thread )
1282         return false;
1283     b_seekable = var_GetBool( p_input_thread, "can-seek" );
1284     vlc_object_release( p_input_thread );
1285
1286     return b_seekable;
1287 }
1288
1289 /* internal function, used by audio, video */
1290 libvlc_track_description_t *
1291         libvlc_get_track_description( libvlc_media_player_t *p_mi,
1292                                       const char *psz_variable )
1293 {
1294     input_thread_t *p_input = libvlc_get_input_thread( p_mi );
1295     libvlc_track_description_t *p_track_description = NULL,
1296                                *p_actual, *p_previous;
1297
1298     if( !p_input )
1299         return NULL;
1300
1301     vlc_value_t val_list, text_list;
1302     var_Change( p_input, psz_variable, VLC_VAR_GETLIST, &val_list, &text_list);
1303
1304     /* no tracks */
1305     if( val_list.p_list->i_count <= 0 )
1306         goto end;
1307
1308     p_track_description = ( libvlc_track_description_t * )
1309         malloc( sizeof( libvlc_track_description_t ) );
1310     if ( !p_track_description )
1311     {
1312         libvlc_printerr( "Not enough memory" );
1313         goto end;
1314     }
1315     p_actual = p_track_description;
1316     p_previous = NULL;
1317     for( int i = 0; i < val_list.p_list->i_count; i++ )
1318     {
1319         if( !p_actual )
1320         {
1321             p_actual = ( libvlc_track_description_t * )
1322                 malloc( sizeof( libvlc_track_description_t ) );
1323             if ( !p_actual )
1324             {
1325                 libvlc_track_description_release( p_track_description );
1326                 libvlc_printerr( "Not enough memory" );
1327                 goto end;
1328             }
1329         }
1330         p_actual->i_id = val_list.p_list->p_values[i].i_int;
1331         p_actual->psz_name = strdup( text_list.p_list->p_values[i].psz_string );
1332         p_actual->p_next = NULL;
1333         if( p_previous )
1334             p_previous->p_next = p_actual;
1335         p_previous = p_actual;
1336         p_actual =  NULL;
1337     }
1338
1339 end:
1340     var_FreeList( &val_list, &text_list );
1341     vlc_object_release( p_input );
1342
1343     return p_track_description;
1344 }
1345
1346 void libvlc_track_description_release( libvlc_track_description_t *p_td )
1347 {
1348     libvlc_track_description_t *p_actual, *p_before;
1349     p_actual = p_td;
1350
1351     while ( p_actual )
1352     {
1353         free( p_actual->psz_name );
1354         p_before = p_actual;
1355         p_actual = p_before->p_next;
1356         free( p_before );
1357     }
1358 }
1359
1360 int libvlc_media_player_can_pause( libvlc_media_player_t *p_mi )
1361 {
1362     input_thread_t *p_input_thread;
1363     bool b_can_pause;
1364
1365     p_input_thread = libvlc_get_input_thread ( p_mi );
1366     if ( !p_input_thread )
1367         return false;
1368     b_can_pause = var_GetBool( p_input_thread, "can-pause" );
1369     vlc_object_release( p_input_thread );
1370
1371     return b_can_pause;
1372 }
1373
1374 void libvlc_media_player_next_frame( libvlc_media_player_t *p_mi )
1375 {
1376     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
1377     if( p_input_thread != NULL )
1378     {
1379         var_TriggerCallback( p_input_thread, "frame-next" );
1380         vlc_object_release( p_input_thread );
1381     }
1382 }