Changeset 445d63e0e38053c1e724982fcc9f661a3bf03ec3

Show
Ignore:
Timestamp:
04/23/08 19:35:01 (2 months ago)
Author:
Olivier Aubert <olivier.aubert@liris.cnrs.fr>
git-committer:
Olivier Aubert <olivier.aubert@liris.cnrs.fr> 1208972101 +0200
git-parent:

[0b96b7ca02af144cbd93dea9f9393ffb7d1b3a15]

git-author:
Olivier Aubert <olivier.aubert@liris.cnrs.fr> 1208955292 +0200
Message:

mediacontrol API: update to use the new libvlc_media_player/libvlc_media API.

This implies the removal of playlist support (single-file playing only, through set_mrl/get_mrl methods). Position parameters for _pause, _resume and _stop method have also been removed.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • include/vlc/mediacontrol.h

    r449fd28 r445d63e  
    132132 
    133133/** 
     134 * Get the associated libvlc_media_player 
     135 * \param self: the mediacontrol instance 
     136 * \return a libvlc_media_player_t instance 
     137 */ 
     138VLC_PUBLIC_API libvlc_media_player_t* 
     139mediacontrol_get_media_player( mediacontrol_Instance* self ); 
     140 
     141/** 
    134142 * Get the current position 
    135143 * \param self the mediacontrol instance 
    …… 
    168176 * Pause the movie at a given position 
    169177 * \param self the mediacontrol instance 
    170  * \param a_position a mediacontrol_Position (ignored for now) 
    171178 * \param exception an initialized exception pointer 
    172179 */ 
    173180VLC_PUBLIC_API void mediacontrol_pause( mediacontrol_Instance *self, 
    174                          const mediacontrol_Position *a_position, 
    175181                         mediacontrol_Exception *exception ); 
    176182 
    …… 
    178184 * Resume the movie at a given position 
    179185 * \param self the mediacontrol instance 
    180  * \param a_position a mediacontrol_Position (ignored for now) 
    181186 * \param exception an initialized exception pointer 
    182187 */ 
    183188VLC_PUBLIC_API void mediacontrol_resume( mediacontrol_Instance *self, 
    184                           const mediacontrol_Position *a_position, 
    185189                          mediacontrol_Exception *exception ); 
    186190 
    …… 
    188192 * Stop the movie at a given position 
    189193 * \param self the mediacontrol instance 
    190  * \param a_position a mediacontrol_Position (ignored for now) 
    191194 * \param exception an initialized exception pointer 
    192195 */ 
    193196VLC_PUBLIC_API void mediacontrol_stop( mediacontrol_Instance *self, 
    194                         const mediacontrol_Position *a_position, 
    195197                        mediacontrol_Exception *exception ); 
    196198 
    …… 
    202204 
    203205/** 
    204  * Add a new MRL to the playlist 
     206 * Set the MRL to be played. 
    205207 * \param self the mediacontrol instance 
    206208 * \param psz_file the MRL 
    207209 * \param exception an initialized exception pointer 
    208210 */ 
    209 VLC_PUBLIC_API void mediacontrol_playlist_add_item( mediacontrol_Instance *self, 
     211VLC_PUBLIC_API void mediacontrol_set_mrl( mediacontrol_Instance *self, 
    210212                                     const char* psz_file, 
    211213                                     mediacontrol_Exception *exception ); 
    212 /** 
    213  * Clear the playlist 
    214  * \param self the mediacontrol instance 
    215  * \param exception an initialized exception pointer 
    216  */ 
    217 VLC_PUBLIC_API void mediacontrol_playlist_clear( mediacontrol_Instance *self, 
    218                                   mediacontrol_Exception *exception ); 
    219 /** 
    220  * Get a flattened view of the playlist 
    221  * \param self the mediacontrol instance 
    222  * \param exception an initialized exception pointer 
    223  * \return a list of strings 
    224  */ 
    225 VLC_PUBLIC_API mediacontrol_PlaylistSeq * 
    226   mediacontrol_playlist_get_list( mediacontrol_Instance *self, 
    227                                   mediacontrol_Exception *exception ); 
    228  
    229 /** 
    230  * Play the next item 
    231  * \param self the mediacontrol instance 
    232  * \param exception an initialized exception pointer 
    233  */ 
    234 VLC_PUBLIC_API void 
    235 mediacontrol_playlist_next_item( mediacontrol_Instance *self, 
    236                                  mediacontrol_Exception *exception ); 
     214 
     215/** 
     216 * Get the MRL to be played. 
     217 * \param self the mediacontrol instance 
     218 * \param exception an initialized exception pointer 
     219 */ 
     220VLC_PUBLIC_API char * mediacontrol_get_mrl( mediacontrol_Instance *self, 
     221                        mediacontrol_Exception *exception ); 
    237222 
    238223/***************************************************************************** 
    …… 
    250235                         const mediacontrol_Position *a_position, 
    251236                         mediacontrol_Exception *exception ); 
    252  
    253 /* Return a NULL terminated list */ 
    254 /** 
    255  * Get a list of all cached snapshots (unimplemented) 
    256  * \param self the mediacontrol instance 
    257  * \param exception an initialized exception pointer 
    258  * \return a NULL-terminated list of RGBpicture 
    259  */ 
    260 VLC_PUBLIC_API mediacontrol_RGBPicture ** 
    261   mediacontrol_all_snapshots( mediacontrol_Instance *self, 
    262                               mediacontrol_Exception *exception ); 
    263237 
    264238/** 

  • src/control/mediacontrol_audio_video.c

    r449fd28 r445d63e  
    2626#endif 
    2727#include "mediacontrol_internal.h" 
     28#include "libvlc_internal.h" 
    2829 
    2930#include <vlc/mediacontrol.h> 
    3031#include <vlc/libvlc.h> 
    31  
    32 #include <vlc_playlist.h> 
    33  
    34 #include <vlc_aout.h> 
    3532 
    3633#include <vlc_vout.h> 
    …… 
    6158    vlc_object_t* p_cache; 
    6259    vout_thread_t* p_vout; 
     60    input_thread_t *p_input; 
    6361    mediacontrol_RGBPicture *p_pic = NULL; 
    6462    char path[256]; 
    6563    snapshot_t *p_snapshot; 
    66  
    67     mediacontrol_exception_init( exception ); 
    68  
    69     p_vout = vlc_object_find( self->p_playlist, VLC_OBJECT_VOUT, FIND_CHILD ); 
     64    libvlc_exception_t ex; 
     65 
     66    libvlc_exception_init( &ex ); 
     67    mediacontrol_exception_init( exception ); 
     68 
     69    p_input = libvlc_get_input_thread( self->p_media_player, &ex ); 
     70    if( ! p_input ) 
     71    { 
     72        RAISE_NULL( mediacontrol_InternalException, "No input" ); 
     73    } 
     74    p_vout = vlc_object_find( p_input, VLC_OBJECT_VOUT, FIND_CHILD ); 
    7075    if( ! p_vout ) 
    7176    { 
    7277        RAISE_NULL( mediacontrol_InternalException, "No video output" ); 
    7378    } 
    74     p_cache = vlc_object_create( self->p_playlist, VLC_OBJECT_GENERIC ); 
     79    p_cache = vlc_object_create( p_input, VLC_OBJECT_GENERIC ); 
    7580    if( p_cache == NULL ) 
    7681    { 
    7782        vlc_object_release( p_vout ); 
     83        vlc_object_release( p_input ); 
    7884        RAISE_NULL( mediacontrol_InternalException, "Out of memory" ); 
    7985    } 
    …… 
    9096    vlc_object_unlock( p_cache ); 
    9197    vlc_object_release( p_cache ); 
     98    vlc_object_release( p_input ); 
    9299 
    93100    if( p_snapshot ) 
    …… 
    113120} 
    114121 
    115 mediacontrol_RGBPicture ** 
    116 mediacontrol_all_snapshots( mediacontrol_Instance *self, 
    117                             mediacontrol_Exception *exception ) 
    118 { 
    119     mediacontrol_exception_init( exception ); 
    120  
    121     RAISE_NULL( mediacontrol_InternalException, "unsupported method" ); 
    122 } 
    123  
    124122static 
    125123int mediacontrol_showtext( vout_thread_t *p_vout, int i_channel, 
    …… 
    175173                           mediacontrol_Exception *exception ) 
    176174{ 
    177     input_thread_t *p_input = NULL; 
    178175    vout_thread_t *p_vout = NULL; 
    179176    char* psz_message; 
     177    input_thread_t *p_input; 
     178    libvlc_exception_t ex; 
     179 
     180    libvlc_exception_init( &ex ); 
     181    mediacontrol_exception_init( exception ); 
     182 
     183    p_input = libvlc_get_input_thread( self->p_media_player, &ex ); 
     184    if( ! p_input ) 
     185    { 
     186        RAISE_VOID( mediacontrol_InternalException, "No input" ); 
     187    } 
     188    p_vout = vlc_object_find( p_input, VLC_OBJECT_VOUT, FIND_CHILD ); 
     189    if( ! p_vout ) 
     190    { 
     191        RAISE_VOID( mediacontrol_InternalException, "No video output" ); 
     192    } 
    180193 
    181194    psz_message = strdup( message ); 
    …… 
    183196    { 
    184197        RAISE_VOID( mediacontrol_InternalException, "no more memory" ); 
    185     } 
    186  
    187     p_vout = vlc_object_find( self->p_playlist, VLC_OBJECT_VOUT, FIND_CHILD ); 
    188     if( ! p_vout ) 
    189     { 
    190         RAISE_VOID( mediacontrol_InternalException, "no video output" ); 
    191198    } 
    192199 
    …… 
    199206 
    200207        i_duration = 1000 * private_mediacontrol_unit_convert( 
    201                                                 self->p_playlist->p_input, 
    202                                                 end->key, 
    203                                                 mediacontrol_MediaTime, 
    204                                                 end->value ); 
     208                                 self->p_media_player, 
     209                                 end->key, 
     210                                 mediacontrol_MediaTime, 
     211                                 end->value ); 
    205212 
    206213        mediacontrol_showtext( p_vout, DEFAULT_CHAN, psz_message, NULL, 
    …… 
    212219        mtime_t i_debut, i_fin, i_now; 
    213220 
    214         p_input = self->p_playlist->p_input; 
    215         if( ! p_input ) 
    216         { 
    217             vlc_object_release( p_vout ); 
    218             RAISE_VOID( mediacontrol_InternalException, "No input" ); 
    219         } 
    220  
    221221        /* FIXME */ 
    222222        /* i_now = input_ClockGetTS( p_input, NULL, 0 ); */ 
    223223        i_now = mdate(); 
    224224 
    225         i_debut = private_mediacontrol_position2microsecond( p_input, 
     225        i_debut = private_mediacontrol_position2microsecond( self->p_media_player, 
    226226                                            ( mediacontrol_Position* ) begin ); 
    227227        i_debut += i_now; 
    228228 
    229         i_fin = private_mediacontrol_position2microsecond( p_input, 
     229        i_fin = private_mediacontrol_position2microsecond( self->p_media_player, 
    230230                                          ( mediacontrol_Position * ) end ); 
    231231        i_fin += i_now; 
    …… 
    279279    libvlc_exception_init( &ex ); 
    280280 
    281     libvlc_video_set_parent( self->p_instance, visual_id, &ex ); 
     281    libvlc_media_player_set_drawable( self->p_media_player, visual_id, &ex ); 
    282282    HANDLE_LIBVLC_EXCEPTION_ZERO( &ex ); 
    283283    return true; 
    …… 
    289289{ 
    290290    libvlc_exception_t ex; 
    291     libvlc_media_player_t* p_mi; 
    292291    int i_ret; 
    293292 
    …… 
    295294    libvlc_exception_init( &ex ); 
    296295 
    297     p_mi = libvlc_playlist_get_media_player( self->p_instance, &ex ); 
    298     HANDLE_LIBVLC_EXCEPTION_ZERO( &ex ); 
    299  
    300     i_ret = libvlc_media_player_get_rate( p_mi, &ex ); 
    301     libvlc_media_player_release( p_mi ); 
     296    i_ret = libvlc_media_player_get_rate( self->p_media_player, &ex ); 
    302297    HANDLE_LIBVLC_EXCEPTION_ZERO( &ex ); 
    303298 
    …… 
    311306{ 
    312307    libvlc_exception_t ex; 
    313     libvlc_media_player_t* p_mi; 
    314  
    315     mediacontrol_exception_init( exception ); 
    316     libvlc_exception_init( &ex ); 
    317  
    318     p_mi = libvlc_playlist_get_media_player( self->p_instance, &ex ); 
    319     HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    320  
    321     libvlc_media_player_set_rate( p_mi, rate * 10, &ex ); 
    322     libvlc_media_player_release( p_mi ); 
     308 
     309    mediacontrol_exception_init( exception ); 
     310    libvlc_exception_init( &ex ); 
     311 
     312    libvlc_media_player_set_rate( self->p_media_player, rate * 10, &ex ); 
    323313    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    324314} 
    …… 
    329319{ 
    330320    libvlc_exception_t ex; 
    331     libvlc_media_player_t* p_mi; 
    332321    int i_ret; 
    333322 
    …… 
    335324    libvlc_exception_init( &ex ); 
    336325 
    337     p_mi = libvlc_playlist_get_media_player( self->p_instance, &ex ); 
    338     HANDLE_LIBVLC_EXCEPTION_ZERO( &ex ); 
    339  
    340     i_ret = libvlc_get_fullscreen( p_mi, &ex ); 
    341     libvlc_media_player_release( p_mi ); 
     326    i_ret = libvlc_get_fullscreen( self->p_media_player, &ex ); 
    342327    HANDLE_LIBVLC_EXCEPTION_ZERO( &ex ); 
    343328 
    …… 
    351336{ 
    352337    libvlc_exception_t ex; 
    353     libvlc_media_player_t* p_mi; 
    354  
    355     mediacontrol_exception_init( exception ); 
    356     libvlc_exception_init( &ex ); 
    357  
    358     p_mi = libvlc_playlist_get_media_player( self->p_instance, &ex ); 
     338 
     339    mediacontrol_exception_init( exception ); 
     340    libvlc_exception_init( &ex ); 
     341 
     342    libvlc_set_fullscreen( self->p_media_player, b_fullscreen, &ex ); 
    359343    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    360  
    361     libvlc_set_fullscreen( p_mi, b_fullscreen, &ex ); 
    362     libvlc_media_player_release( p_mi ); 
    363     HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    364 } 
     344} 

  • src/control/mediacontrol_core.c

    rbf1292e r445d63e  
    7070    retval->p_instance = libvlc_new( argc, (const char**)argv, &ex ); 
    7171    HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
    72     retval->p_playlist = retval->p_instance->p_libvlc_int->p_playlist; 
     72    retval->p_media_player = libvlc_media_player_new( retval->p_instance, &ex ); 
     73    HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
    7374    return retval; 
    7475} 
    …… 
    8384mediacontrol_get_libvlc_instance( mediacontrol_Instance *self ) 
    8485{ 
    85   return self->p_instance; 
     86    return self->p_instance; 
     87} 
     88 
     89libvlc_media_player_t* 
     90mediacontrol_get_media_player( mediacontrol_Instance *self ) 
     91{ 
     92    return self->p_media_player; 
    8693} 
    8794 
    …… 
    9097                mediacontrol_Exception *exception ) 
    9198{ 
    92   mediacontrol_Instance* retval; 
    93  
    94   retval = ( mediacontrol_Instance* )malloc( sizeof( mediacontrol_Instance ) ); 
    95   if( ! retval ) 
    96   { 
    97       RAISE_NULL( mediacontrol_InternalException, "Out of memory" ); 
    98   } 
    99   retval->p_instance = p_instance; 
    100   retval->p_playlist = retval->p_instance->p_libvlc_int->p_playlist; 
    101   return retval; 
     99    mediacontrol_Instance* retval; 
     100    libvlc_exception_t ex; 
     101     
     102    libvlc_exception_init( &ex ); 
     103     
     104    retval = ( mediacontrol_Instance* )malloc( sizeof( mediacontrol_Instance ) ); 
     105    if( ! retval ) 
     106    { 
     107        RAISE_NULL( mediacontrol_InternalException, "Out of memory" ); 
     108    } 
     109    retval->p_instance = p_instance; 
     110    retval->p_media_player = libvlc_media_player_new( retval->p_instance, &ex ); 
     111    HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
     112    return retval; 
    102113} 
    103114 
    …… 
    114125    libvlc_exception_t ex; 
    115126    vlc_int64_t pos; 
    116     libvlc_media_player_t * p_mi; 
    117127 
    118128    mediacontrol_exception_init( exception ); 
    …… 
    123133    retval->key = a_key; 
    124134 
    125     p_mi = libvlc_playlist_get_media_player( self->p_instance, &ex); 
    126     HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
    127  
    128135    if(  an_origin != mediacontrol_AbsolutePosition ) 
    129136    { 
    130         libvlc_media_player_release( p_mi ); 
    131137        /* Relative or ModuloPosition make no sense */ 
    132138        RAISE_NULL( mediacontrol_PositionOriginNotSupported, 
    …… 
    135141 
    136142    /* We are asked for an AbsolutePosition. */ 
    137     pos = libvlc_media_player_get_time( p_mi, &ex ); 
     143    pos = libvlc_media_player_get_time( self->p_media_player, &ex ); 
    138144 
    139145    if( a_key == mediacontrol_MediaTime ) 
    …… 
    143149    else 
    144150    { 
    145         if( ! self->p_playlist->p_input ) 
    146         { 
    147             libvlc_media_player_release( p_mi ); 
    148             RAISE_NULL( mediacontrol_InternalException, 
    149                         "No input" ); 
    150         } 
    151         retval->value = private_mediacontrol_unit_convert( self->p_playlist->p_input, 
    152                                                    mediacontrol_MediaTime, 
    153                                                    a_key, 
    154                                                    pos ); 
    155     } 
    156     libvlc_media_player_release( p_mi ); 
     151        retval->value = private_mediacontrol_unit_convert( self->p_media_player, 
     152                                                           mediacontrol_MediaTime, 
     153                                                           a_key, 
     154                                                           pos ); 
     155    } 
    157156    return retval; 
    158157} 
    …… 
    164163                                 mediacontrol_Exception *exception ) 
    165164{ 
    166     libvlc_media_player_t * p_mi; 
    167165    libvlc_exception_t ex; 
    168166    vlc_int64_t i_pos; 
    …… 
    171169    mediacontrol_exception_init( exception ); 
    172170 
    173     p_mi = libvlc_playlist_get_media_player( self->p_instance, &ex); 
    174     HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    175  
    176     i_pos = private_mediacontrol_position2microsecond( self->p_playlist->p_input, a_position ); 
    177     libvlc_media_player_set_time( p_mi, i_pos / 1000, &ex ); 
    178     libvlc_media_player_release( p_mi ); 
     171    i_pos = private_mediacontrol_position2microsecond( self->p_media_player, a_position ); 
     172    libvlc_media_player_set_time( self->p_media_player, i_pos / 1000, &ex ); 
    179173    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    180174} 
    …… 
    195189                    mediacontrol_Exception *exception ) 
    196190{ 
    197     playlist_t * p_playlist = self->p_playlist; 
    198  
    199     mediacontrol_exception_init( exception ); 
    200     if( ! p_playlist ) 
    201     { 
    202         RAISE( mediacontrol_PlaylistException, "No available playlist" ); 
    203         return; 
    204     } 
    205  
    206     vlc_mutex_lock( &p_playlist->object_lock ); 
    207     if( p_playlist->items.i_size ) 
    208     { 
    209         int i_from; 
    210         char *psz_from = NULL; 
    211  
    212         psz_from = ( char * )malloc( 20 * sizeof( char ) ); 
    213         if( psz_from && p_playlist->status.p_item ) 
     191    libvlc_media_t * p_media; 
     192    char * psz_name; 
     193    libvlc_exception_t ex; 
     194 
     195    mediacontrol_exception_init( exception ); 
     196    libvlc_exception_init( &ex ); 
     197     
     198    p_media = libvlc_media_player_get_media( self->p_media_player, &ex ); 
     199    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     200 
     201    if ( ! p_media ) 
     202    { 
     203        /* No media was defined. */ 
     204        RAISE( mediacontrol_PlaylistException, "No defined media." ); 
     205    } 
     206    else 
     207    { 
     208        /* A media was defined. Get its mrl to reuse it, but reset the options 
     209           (because start-time may have been set on the previous invocation */ 
     210        psz_name = libvlc_media_get_mrl( p_media, &ex ); 
     211        HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     212 
     213        /* Create a new media */ 
     214        p_media = libvlc_media_new( self->p_instance, psz_name, &ex ); 
     215        HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     216         
     217        if( a_position->value ) 
    214218        { 
    215             i_from = private_mediacontrol_position2microsecond( p_playlist->p_input, a_position ) / 1000000; 
    216  
    217             /* Set start time */ 
    218             snprintf( psz_from, 20, "start-time=%i", i_from ); 
    219             input_ItemAddOption( p_playlist->status.p_item->p_input, psz_from ); 
    220             free( psz_from ); 
     219            char * psz_from; 
     220            libvlc_time_t i_from; 
     221 
     222            /* A start position was specified. Add it to media options */ 
     223            psz_from = ( char * )malloc( 20 * sizeof( char ) ); 
     224            i_from = private_mediacontrol_position2microsecond( self->p_media_player, a_position ) / 1000000; 
     225            snprintf( psz_from, 20, "start-time=%ld", i_from ); 
     226            libvlc_media_add_option( p_media, psz_from, &ex ); 
     227            HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    221228        } 
    222  
    223         vlc_mutex_unlock( &p_playlist->object_lock ); 
    224         playlist_Play( p_playlist ); 
     229         
     230        libvlc_media_player_set_media( self->p_media_player, p_media, &ex ); 
     231        HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     232 
     233        libvlc_media_player_play( self->p_media_player, &ex ); 
     234        HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     235    } 
     236} 
     237 
     238void 
     239mediacontrol_pause( mediacontrol_Instance *self, 
     240                    mediacontrol_Exception *exception ) 
     241{ 
     242    libvlc_exception_t ex; 
     243 
     244    mediacontrol_exception_init( exception ); 
     245    libvlc_exception_init( &ex ); 
     246    libvlc_media_player_pause( self->p_media_player, &ex ); 
     247    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     248} 
     249 
     250void 
     251mediacontrol_resume( mediacontrol_Instance *self, 
     252                     mediacontrol_Exception *exception ) 
     253{ 
     254    libvlc_exception_t ex; 
     255 
     256    mediacontrol_exception_init( exception ); 
     257    libvlc_exception_init( &ex ); 
     258    libvlc_media_player_pause( self->p_media_player, &ex ); 
     259    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     260} 
     261 
     262void 
     263mediacontrol_stop( mediacontrol_Instance *self, 
     264                   mediacontrol_Exception *exception ) 
     265{ 
     266    libvlc_exception_t ex; 
     267 
     268    mediacontrol_exception_init( exception ); 
     269    libvlc_exception_init( &ex ); 
     270    libvlc_media_player_stop( self->p_media_player, &ex ); 
     271    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     272} 
     273 
     274/************************************************************************** 
     275 * File management 
     276 **************************************************************************/ 
     277 
     278void 
     279mediacontrol_set_mrl( mediacontrol_Instance *self, 
     280                      const char * psz_file, 
     281                      mediacontrol_Exception *exception ) 
     282{ 
     283    libvlc_media_t * p_media; 
     284    libvlc_exception_t ex; 
     285 
     286    mediacontrol_exception_init( exception ); 
     287    libvlc_exception_init( &ex ); 
     288     
     289    p_media = libvlc_media_new( self->p_instance, psz_file, &ex ); 
     290    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     291 
     292    libvlc_media_player_set_media( self->p_media_player, p_media, &ex ); 
     293    HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
     294} 
     295 
     296char * 
     297mediacontrol_get_mrl( mediacontrol_Instance *self, 
     298                      mediacontrol_Exception *exception ) 
     299{ 
     300    libvlc_media_t * p_media; 
     301    libvlc_exception_t ex; 
     302 
     303    mediacontrol_exception_init( exception ); 
     304    libvlc_exception_init( &ex ); 
     305     
     306    p_media = libvlc_media_player_get_media( self->p_media_player, &ex ); 
     307    HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
     308 
     309    if ( ! p_media ) 
     310    { 
     311        return strdup( "" ); 
    225312    } 
    226313    else 
    227314    { 
    228         RAISE( mediacontrol_PlaylistException, "Empty playlist." ); 
    229         vlc_mutex_unlock( &p_playlist->object_lock ); 
    230     } 
    231 } 
    232  
    233 void 
    234 mediacontrol_pause( mediacontrol_Instance *self, 
    235                     const mediacontrol_Position * a_position, 
    236                     mediacontrol_Exception *exception ) 
    237 { 
    238     input_thread_t *p_input = self->p_playlist->p_input; 
    239  
    240     /* FIXME: use the a_position parameter */ 
    241     mediacontrol_exception_init( exception ); 
    242     if( p_input != NULL ) 
    243     { 
    244         var_SetInteger( p_input, "state", PAUSE_S ); 
    245     } 
    246     else 
    247     { 
    248         RAISE( mediacontrol_InternalException, "No input" ); 
    249     } 
    250 } 
    251  
    252 void 
    253 mediacontrol_resume( mediacontrol_Instance *self, 
    254                      const mediacontrol_Position * a_position, 
    255                      mediacontrol_Exception *exception ) 
    256 { 
    257     input_thread_t *p_input = self->p_playlist->p_input; 
    258  
    259     /* FIXME: use the a_position parameter */ 
    260     mediacontrol_exception_init( exception ); 
    261     if( p_input != NULL ) 
    262     { 
    263         var_SetInteger( p_input, "state", PAUSE_S ); 
    264     } 
    265     else 
    266     { 
    267         RAISE( mediacontrol_InternalException, "No input" ); 
    268     } 
    269 } 
    270  
    271 void 
    272 mediacontrol_stop( mediacontrol_Instance *self, 
    273                    const mediacontrol_Position * a_position, 
    274                    mediacontrol_Exception *exception ) 
    275 { 
    276     /* FIXME: use the a_position parameter */ 
    277     mediacontrol_exception_init( exception ); 
    278     if( !self->p_playlist ) 
    279     { 
    280         RAISE( mediacontrol_PlaylistException, "No playlist" ); 
    281     } 
    282     else 
    283         playlist_Stop( self->p_playlist ); 
    284 } 
    285  
    286 /************************************************************************** 
    287  * Playlist management 
    288  **************************************************************************/ 
    289  
    290 void 
    291 mediacontrol_playlist_add_item( mediacontrol_Instance *self, 
    292                                 const char * psz_file, 
    293                                 mediacontrol_Exception *exception ) 
    294 { 
    295     libvlc_exception_t ex; 
    296  
    297     mediacontrol_exception_init( exception ); 
    298     libvlc_exception_init( &ex ); 
    299  
    300     libvlc_playlist_add( self->p_instance, psz_file, psz_file, &ex ); 
    301     HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    302 } 
    303  
    304 void 
    305 mediacontrol_playlist_next_item( mediacontrol_Instance *self, 
    306                                  mediacontrol_Exception *exception ) 
    307 { 
    308     libvlc_exception_t ex; 
    309  
    310     mediacontrol_exception_init( exception ); 
    311     libvlc_exception_init( &ex ); 
    312  
    313     libvlc_playlist_next( self->p_instance, &ex ); 
    314     HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    315 } 
    316  
    317 void 
    318 mediacontrol_playlist_clear( mediacontrol_Instance *self, 
    319                              mediacontrol_Exception *exception ) 
    320 { 
    321     libvlc_exception_t ex; 
    322  
    323     mediacontrol_exception_init( exception ); 
    324     libvlc_exception_init( &ex ); 
    325  
    326     libvlc_playlist_clear( self->p_instance, &ex ); 
    327     HANDLE_LIBVLC_EXCEPTION_VOID( &ex ); 
    328 } 
    329  
    330 mediacontrol_PlaylistSeq * 
    331 mediacontrol_playlist_get_list( mediacontrol_Instance *self, 
    332                                 mediacontrol_Exception *exception ) 
    333 { 
    334     mediacontrol_PlaylistSeq *retval = NULL; 
    335     int i_index; 
    336     playlist_t * p_playlist = self->p_playlist; 
    337     playlist_item_t *p_root; 
    338     int i_playlist_size; 
    339  
    340     mediacontrol_exception_init( exception ); 
    341     if( !p_playlist ) 
    342     { 
    343         RAISE( mediacontrol_PlaylistException, "No playlist" ); 
    344         return NULL; 
    345     } 
    346  
    347     vlc_mutex_lock( &p_playlist->object_lock ); 
    348  
    349     p_root = p_playlist->p_root_onelevel->pp_children[0]; 
    350     i_playlist_size = p_root->i_children; 
    351     retval = private_mediacontrol_PlaylistSeq__alloc( i_playlist_size ); 
    352  
    353     for( i_index = 0 ; i_index < i_playlist_size ; i_index++ ) 
    354     { 
    355         retval->data[i_index] = strdup( p_root->pp_children[i_index]->p_input->psz_name ); 
    356     } 
    357     vlc_mutex_unlock( &p_playlist->object_lock ); 
    358  
    359     return retval; 
     315        char * psz_mrl; 
     316 
     317        psz_mrl = libvlc_media_get_mrl( p_media, &ex ); 
     318        HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
     319        return psz_mrl; 
     320    } 
    360321} 
    361322 
    …… 
    370331{ 
    371332    mediacontrol_StreamInformation *retval = NULL; 
    372     input_thread_t *p_input = self->p_playlist->p_input; 
    373     vlc_value_t val; 
     333    libvlc_media_t * p_media; 
     334    libvlc_exception_t ex; 
     335 
     336    libvlc_exception_init( &ex ); 
    374337 
    375338    retval = ( mediacontrol_StreamInformation* ) 
    …… 
    381344    } 
    382345 
    383     if( ! p_input ) 
    384     { 
    385         /* No p_input defined */ 
     346    p_media = libvlc_media_player_get_media( self->p_media_player, &ex ); 
     347    HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
     348    if( ! p_media ) 
     349    { 
     350        /* No p_media defined */ 
    386351        retval->streamstatus = mediacontrol_UndefinedStatus; 
    387352        retval->url          = strdup( "None" ); 
    …… 
    391356    else 
    392357    { 
    393         switch( var_GetInteger( p_input, "state" ) ) 
     358        libvlc_state_t state; 
     359 
     360        state = libvlc_media_player_get_state( self->p_media_player, &ex ); 
     361        HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); 
     362        switch( state ) 
    394363        { 
    395         case PLAYING_S    : 
     364        case libvlc_Playing : 
    396365            retval->streamstatus = mediacontrol_PlayingStatus; 
    397366            break; 
    398         case PAUSE_S      : 
     367        case libvlc_Paused : 
    399368            retval->streamstatus = mediacontrol_PauseStatus; 
    400369            break; 
    401         case INIT_S        : 
     370        case libvlc_Opening : 
     371        case libvlc_Buffering: 
    402372            retval->streamstatus = mediacontrol_InitStatus; 
    403373            break; 
    404         case END_S         : 
     374        case libvlc_Stopped: 
     375        case libvlc_Ended: 
    405376            retval->streamstatus = mediacontrol_EndStatus; 
    406377            break; 
    …… 
    410381        } 
    411382 
    412         retval->url = input_item_GetURI( input_GetItem( p_input ) ); 
     383        retval->url = libvlc_media_get_mrl( p_media, &ex ); 
    413384 
    414385        /* TIME and LENGTH are in microseconds. We want them in ms */ 
    415         var_Get( p_input, "time", &val); 
    416         retval->position = val.i_time / 1000; 
    417  
    418         var_Get( p_input, "length", &val); 
    419         retval->length = val.i_time / 1000; 
    420  
    421         retval->position = private_mediacontrol_unit_convert( p_input, 
     386        retval->position = libvlc_media_player_get_time( self->p_media_player, &ex ); 
     387 
     388        retval->length = libvlc_media_player_get_length( self->p_media_player, &ex ); 
     389 
     390        retval->position = private_mediacontrol_unit_convert( self->p_media_player, 
    422391                                         mediacontrol_MediaTime, a_key, 
    423392                                         retval->position ); 
    424         retval->length   = private_mediacontrol_unit_convert( p_input, 
     393        retval->length   = private_mediacontrol_unit_convert( self->p_media_player, 
    425394                                         mediacontrol_MediaTime, a_key, 
    426395                                         retval->length ); 

  • src/control/mediacontrol_internal.h

    r3b0c979 r445d63e  
    3131#include <vlc/vlc.h> 
    3232#include <vlc/mediacontrol_structures.h> 
    33 #include "libvlc_internal.h" 
     33#include <vlc/libvlc_structures.h> 
    3434#include <vlc/libvlc.h> 
    3535 
    3636struct mediacontrol_Instance { 
    37     struct libvlc_instance_t * p_instance; 
    38     playlist_t    *p_playlist; 
     37    libvlc_instance_t * p_instance; 
     38    libvlc_media_player_t * p_media_player; 
    3939}; 
    4040 
    41 vlc_int64_t private_mediacontrol_unit_convert( input_thread_t *p_input, 
    42                            mediacontrol_PositionKey from, 
    43                            mediacontrol_PositionKey to, 
    44                            vlc_int64_t value ); 
    45 vlc_int64_t private_mediacontrol_position2microsecond( input_thread_t *p_input, 
    46                                const mediacontrol_Position *pos ); 
     41libvlc_time_t private_mediacontrol_unit_convert( libvlc_media_player_t *p_media_player, 
     42                                                 mediacontrol_PositionKey from, 
     43                                                 mediacontrol_PositionKey to, 
     44                                                 vlc_int64_t value ); 
     45libvlc_time_t private_mediacontrol_position2microsecond( libvlc_media_player_t *p_media_player, 
     46                                                         const mediacontrol_Position *pos ); 
    4747 
    4848/** 
    …… 
    5353 
    5454mediacontrol_RGBPicture *private_mediacontrol_createRGBPicture( int, int, long, vlc_int64_t l_date, char *, int); 
    55  
    56 mediacontrol_PlaylistSeq *private_mediacontrol_PlaylistSeq__alloc( int size ); 
    5755 
    5856 

  • src/control/mediacontrol_util.c

    r57bbabb r445d63e  
    2727 
    2828#include <vlc/mediacontrol.h> 
    29  
    30 #include <vlc_interface.h> 
    31 #include <vlc_aout.h> 
    32 #include <vlc_input.h> 
    33 #include <vlc_demux.h> 
     29#include <vlc/libvlc.h> 
    3430 
    3531#include <vlc_vout.h> 
    …… 
    5450#endif 
    5551 
    56 /* FIXME: Need to stop accessing private input structures !! */ 
    57 #include "input/input_internal.h" 
    58  
    59 vlc_int64_t private_mediacontrol_unit_convert( input_thread_t *p_input, 
    60                                        mediacontrol_PositionKey from, 
    61                                        mediacontrol_PositionKey to, 
    62                                        vlc_int64_t value ) 
     52libvlc_time_t private_mediacontrol_unit_convert( libvlc_media_player_t *p_media_player, 
     53                                                 mediacontrol_PositionKey from, 
     54                                                 mediacontrol_PositionKey to, 
     55                                                 vlc_int64_t value ) 
    6356{ 
    6457    if( to == from ) 
    6558        return value; 
    6659 
    67     /* For all conversions, we need data from p_input */ 
    68     if( !p_input ) 
     60    if( !p_media_player ) 
    6961        return 0; 
    7062 
    …… 
    7466        if( to == mediacontrol_ByteCount ) 
    7567        { 
    76             /* FIXME */ 
     68            /* FIXME Unsupported */ 
    7769            /* vlc < 0.8 API */ 
    7870            /* return value * 50 * p_input->stream.i_mux_rate / 1000; */ 
    …… 
    8274        { 
    8375            double f_fps; 
    84  
    85             if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_FPS, &f_fps ) || f_fps < 0.1 ) 
     76        libvlc_exception_t ex; 
     77        libvlc_exception_init( &ex ); 
     78 
     79        f_fps = libvlc_media_player_get_rate( p_media_player, &ex ); 
     80        if( f_fps < 0 ) 
    8681                return 0; 
    8782            else 
    …… 
    9590    { 
    9691        double f_fps; 
    97  
    98         if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_FPS, &f_fps ) || 
    99                                 f_fps < 0.1 ) 
     92        libvlc_exception_t ex; 
     93        libvlc_exception_init( &ex ); 
     94         
     95        f_fps = libvlc_media_player_get_rate( p_media_player, &ex ); 
     96        if( f_fps < 0 ) 
    10097            return 0; 
    10198 
    …… 
    117114        /* FIXME */ 
    118115        return 0; 
    119 /* vlc < 0.8 API: */ 
    120  
    121 //         if( p_input->stream.i_mux_rate == 0 ) 
    122 //             return 0; 
    123 // 
    124 //         /* Convert an offset into milliseconds. Taken from input_ext-intf.c. 
    125 //            The 50 hardcoded constant comes from the definition of i_mux_rate : 
    126 //            i_mux_rate : the rate we read the stream (in units of 50 bytes/s) ; 
    127 //            0 if undef */ 
    128 //         if( to == mediacontrol_MediaTime ) 
    129 //             return ( vlc_int64_t )( 1000 * value / 50 / p_input->stream.i_mux_rate ); 
    130 // 
    131 //         if( to == mediacontrol_SampleCount ) 
    132 //         { 
    133 //             double f_fps; 
    134 //             if( demux_Control( p_input->input.p_demux, DEMUX_GET_FPS, &f_fps ) || f_fps < 0.1 ) 
    135 //                 return 0; 
    136 //             else 
    137 //                 return ( vlc_int64_t )( value * f_fps / 50 / p_input->stream.i_mux_rate ); 
    138 //         } 
    139         /* Cannot happen */ 
    140         break; 
    141116    } 
    142117    /* Cannot happen */ 
    …… 
    146121/* Converts a mediacontrol_Position into a time in microseconds in 
    147122   movie clock time */ 
    148 vlc_int64_t 
    149 private_mediacontrol_position2microsecond( input_thread_t* p_input, const mediacontrol_Position * pos ) 
     123libvlc_time_t 
     124private_mediacontrol_position2microsecond( libvlc_media_player_t * p_media_player,  
     125                                           const mediacontrol_Position * pos ) 
    150126{ 
    151127    switch( pos->origin ) 
    152128    { 
    153129    case mediacontrol_AbsolutePosition: 
    154         return ( 1000 * private_mediacontrol_unit_convert( p_input, 
     130        return ( 1000 * private_mediacontrol_unit_convert( p_media_player, 
    155131                                                   pos->key, /* from */ 
    156132                                                   mediacontrol_MediaTime,  /* to */ 
    …… 
    159135    case mediacontrol_RelativePosition: 
    160136    { 
    161         vlc_int64_t l_pos; 
    162         vlc_value_t val; 
    163  
    164         val.i_time = 0; 
    165         if( p_input ) 
    166         { 
    167             var_Get( p_input, "time", &val ); 
    168         } 
    169  
    170         l_pos = 1000 * private_mediacontrol_unit_convert( p_input, 
    171                                                   pos->key, 
    172