开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
media_player.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：43k
源码类别：

midi

开发平台：

Unix_Linux

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