Changeset 241b22807f106a1473add93ed0d8efdc9108e4bc

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

[66fc00162f3f69e55bd84e7501d966b578b37c21]

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

python bindings: update to the new libvlc and mediacontrol API.

Objects have been renamed (vlc.MediaPlayer?/vlc.Media) to match the current API.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • bindings/python/vlc_instance.c

    rbf1292e r241b228  
    8181    int i_size = 0; 
    8282 
    83     if( PyArg_ParseTuple( args, "O", &py_list ) ) 
     83    fprintf(stderr, "Instancianting\n"); 
     84    if( PyArg_ParseTuple( args, "|O", &py_list ) ) 
    8485    { 
    8586        i_size = pyoptions_to_args( py_list, &ppsz_args ); 
    …… 
    120121} 
    121122 
    122 /* Set loop variable */ 
    123 static PyObject * 
    124 vlcInstance_playlist_loop( PyObject *self, PyObject *args ) 
    125 { 
    126     libvlc_exception_t ex; 
    127     int i_loop = 0; 
    128  
    129     if( !PyArg_ParseTuple( args, "i", &i_loop ) ) 
    130         return NULL; 
    131  
    132     LIBVLC_TRY; 
    133     libvlc_playlist_loop( LIBVLC_INSTANCE->p_instance, i_loop, &ex ); 
    134     LIBVLC_EXCEPT; 
    135  
    136     Py_INCREF( Py_None ); 
    137     return Py_None; 
    138 } 
    139  
    140 /* Playlist play. 2 parameters: i_id, the id to play 
    141    l_options: a list of options */ 
    142 static PyObject * 
    143 vlcInstance_playlist_play( PyObject *self, PyObject *args ) 
    144 { 
    145     libvlc_exception_t ex; 
    146     int i_id = -1; 
    147     PyObject *py_options = NULL; 
    148     int i_size = 0; 
    149     char** ppsz_args = NULL; 
    150  
    151     if( !PyArg_ParseTuple( args, "|iO", &i_id, &py_options ) ) 
    152         return NULL; 
    153  
    154     if( py_options ) 
    155     { 
    156         i_size = pyoptions_to_args( py_options, &ppsz_args ); 
    157     } 
    158  
    159     LIBVLC_TRY; 
    160     libvlc_playlist_play( LIBVLC_INSTANCE->p_instance, i_id, i_size, ppsz_args, &ex ); 
    161     free_args( i_size, ppsz_args ); 
    162     LIBVLC_EXCEPT; 
    163  
    164     Py_INCREF( Py_None ); 
    165     return Py_None; 
    166 } 
    167  
    168 static PyObject * 
    169 vlcInstance_playlist_pause( PyObject *self, PyObject *args ) 
    170 { 
    171     libvlc_exception_t ex; 
    172     LIBVLC_TRY; 
    173     libvlc_playlist_pause( LIBVLC_INSTANCE->p_instance, &ex ); 
    174     LIBVLC_EXCEPT; 
    175     Py_INCREF( Py_None ); 
    176     return Py_None; 
    177 } 
    178  
    179 static PyObject * 
    180 vlcInstance_playlist_isplaying( PyObject *self, PyObject *args ) 
    181 { 
    182     libvlc_exception_t ex; 
    183     int i_ret; 
    184  
    185     LIBVLC_TRY; 
    186     i_ret = libvlc_playlist_isplaying( LIBVLC_INSTANCE->p_instance, &ex ); 
    187     LIBVLC_EXCEPT; 
    188     return Py_BuildValue( "i", i_ret ); 
    189 } 
    190  
    191 static PyObject * 
    192 vlcInstance_playlist_items_count( PyObject *self, PyObject *args ) 
    193 { 
    194     libvlc_exception_t ex; 
    195     int i_ret; 
    196  
    197     LIBVLC_TRY; 
    198     i_ret = libvlc_playlist_items_count( LIBVLC_INSTANCE->p_instance, &ex ); 
    199     LIBVLC_EXCEPT; 
    200     return Py_BuildValue( "i", i_ret ); 
    201 } 
    202  
    203 static PyObject * 
    204 vlcInstance_playlist_stop( PyObject *self, PyObject *args ) 
    205 { 
    206     libvlc_exception_t ex; 
    207     LIBVLC_TRY; 
    208     libvlc_playlist_stop( LIBVLC_INSTANCE->p_instance, &ex ); 
    209     LIBVLC_EXCEPT; 
    210     Py_INCREF( Py_None ); 
    211     return Py_None; 
    212 } 
    213  
    214 static PyObject * 
    215 vlcInstance_playlist_next( PyObject *self, PyObject *args ) 
    216 { 
    217     libvlc_exception_t ex; 
    218     LIBVLC_TRY; 
    219     libvlc_playlist_next( LIBVLC_INSTANCE->p_instance, &ex ); 
    220     LIBVLC_EXCEPT; 
    221     Py_INCREF( Py_None ); 
    222     return Py_None; 
    223 } 
    224  
    225 static PyObject * 
    226 vlcInstance_playlist_prev( PyObject *self, PyObject *args ) 
    227 { 
    228     libvlc_exception_t ex; 
    229     LIBVLC_TRY; 
    230     libvlc_playlist_prev( LIBVLC_INSTANCE->p_instance, &ex ); 
    231     LIBVLC_EXCEPT; 
    232     Py_INCREF( Py_None ); 
    233     return Py_None; 
    234 } 
    235  
    236 static PyObject * 
    237 vlcInstance_playlist_clear( PyObject *self, PyObject *args ) 
    238 { 
    239     libvlc_exception_t ex; 
    240     LIBVLC_TRY; 
    241     libvlc_playlist_clear( LIBVLC_INSTANCE->p_instance, &ex ); 
    242     LIBVLC_EXCEPT; 
    243     Py_INCREF( Py_None ); 
    244     return Py_None; 
    245 } 
    246  
    247 /* Add a playlist item. Main parameter: URI. 
    248    Optional parameters: name, options */ 
    249 static PyObject * 
    250 vlcInstance_playlist_add( PyObject *self, PyObject *args) 
    251 { 
    252     libvlc_exception_t ex; 
    253     int i_ret; 
    254     char* psz_uri = NULL; 
    255     char* psz_name = NULL; 
    256     PyObject *py_options = NULL; 
    257     int i_size = 0; 
    258     char** ppsz_args = NULL; 
    259  
    260     if( !PyArg_ParseTuple( args, "s|sO", &psz_uri, &psz_name, &py_options ) ) 
    261         return NULL; 
    262  
    263     if( !psz_name ) 
    264     { 
    265         /* Set a default name */ 
    266         psz_name = strdup( psz_uri ); 
    267     } 
    268  
    269     if( py_options ) 
    270     { 
    271         i_size = pyoptions_to_args( py_options, &ppsz_args ); 
    272     } 
    273  
    274     LIBVLC_TRY; 
    275     if( ppsz_args ) 
    276     { 
    277         i_ret = libvlc_playlist_add_extended( LIBVLC_INSTANCE->p_instance, 
    278                                               psz_uri, 
    279                                               psz_name, 
    280                                               i_size, 
    281                                               ppsz_args, 
    282                                               &ex ); 
    283         free_args( i_size, ppsz_args ); 
    284     } 
    285     else 
    286     { 
    287         i_ret = libvlc_playlist_add( LIBVLC_INSTANCE->p_instance, 
    288                                      psz_uri, 
    289                                      psz_name, 
    290                                      &ex ); 
    291     } 
    292     LIBVLC_EXCEPT; 
    293  
    294     return Py_BuildValue( "i", i_ret ); 
    295 } 
    296  
    297 static PyObject * 
    298 vlcInstance_playlist_delete_item( PyObject *self, PyObject *args ) 
    299 { 
    300     libvlc_exception_t ex; 
    301     int i_id; 
    302     int i_ret; 
    303  
    304     if( !PyArg_ParseTuple( args, "i", &i_id ) ) 
    305         return NULL; 
    306  
    307     LIBVLC_TRY; 
    308     i_ret = libvlc_playlist_delete_item( LIBVLC_INSTANCE->p_instance, i_id, &ex ); 
    309     LIBVLC_EXCEPT; 
    310  
    311     return Py_BuildValue( "i", i_ret ); 
    312 } 
    313  
    314 static PyObject * 
    315 vlcInstance_playlist_get_media_player( PyObject *self, PyObject *args ) 
    316 { 
    317     libvlc_exception_t ex; 
    318     libvlc_media_player_t *p_mi; 
    319     vlcMediaInstance *p_ret; 
    320  
    321     LIBVLC_TRY; 
    322     p_mi = libvlc_playlist_get_media_player( LIBVLC_INSTANCE->p_instance, &ex ); 
    323     LIBVLC_EXCEPT; 
    324  
    325     p_ret = PyObject_New( vlcMediaInstance, &vlcMediaInstance_Type ); 
    326     p_ret->p_mi = p_mi; 
     123static PyObject * 
     124vlcInstance_new_media_player( PyObject *self, PyObject *args ) 
     125{ 
     126    libvlc_exception_t ex; 
     127    libvlc_media_player_t *p_mp; 
     128    vlcMediaPlayer *p_ret; 
     129 
     130    LIBVLC_TRY; 
     131    p_mp = libvlc_media_player_new( LIBVLC_INSTANCE->p_instance, &ex ); 
     132    LIBVLC_EXCEPT; 
     133 
     134    p_ret = PyObject_New( vlcMediaPlayer, &vlcMediaPlayer_Type ); 
     135    p_ret->p_mp = p_mp; 
    327136    Py_INCREF( p_ret ); /* Ah bon ? */ 
    328137    return ( PyObject * )p_ret; 
    …… 
    734543{ 
    735544    libvlc_exception_t ex; 
    736     libvlc_media_t *p_md; 
     545    libvlc_media_t *p_media; 
    737546    char* psz_mrl = NULL; 
    738     vlcMediaDescriptor *p_ret; 
     547    vlcMedia *p_ret; 
    739548 
    740549    if( !PyArg_ParseTuple( args, "s", &psz_mrl ) ) 
    …… 
    742551 
    743552    LIBVLC_TRY; 
    744     p_md = libvlc_media_new( LIBVLC_INSTANCE->p_instance, psz_mrl, &ex ); 
    745     LIBVLC_EXCEPT; 
    746  
    747     p_ret = PyObject_New( vlcMediaDescriptor, &vlcMediaDescriptor_Type ); 
    748     p_ret->p_md = p_md; 
     553    p_media = libvlc_media_new( LIBVLC_INSTANCE->p_instance, psz_mrl, &ex ); 
     554    LIBVLC_EXCEPT; 
     555 
     556    p_ret = PyObject_New( vlcMedia, &vlcMedia_Type ); 
     557    p_ret->p_media = p_media; 
    749558    Py_INCREF( p_ret ); /* Ah bon ? */ 
    750559    return ( PyObject * )p_ret; 
    …… 
    754563static PyMethodDef vlcInstance_methods[] = 
    755564{ 
    756     { "get_vlc_id", vlcInstance_get_vlc_id, METH_VARARGS, 
     565    { "get_vlc_id", vlcInstance_get_vlc_id, METH_NOARGS, 
    757566      "get_vlc_id( ) -> int        Get the instance id."}, 
    758     { "playlist_loop", vlcInstance_playlist_loop, METH_VARARGS, 
    759       "playlist_loop(bool)         Set loop variable" }, 
    760     { "playlist_play", vlcInstance_playlist_play, METH_VARARGS, 
    761       "playlist_play(id=int, options=list)   Play the given playlist item (-1 for current item) with optional options (a list of strings)" }, 
    762     { "playlist_pause", vlcInstance_playlist_pause, METH_VARARGS, 
    763       "playlist_pause()            Pause the current stream"}, 
    764     { "playlist_isplaying", vlcInstance_playlist_isplaying, METH_VARARGS, 
    765       "playlist_isplaying() -> int     Return True if the playlist if playing"}, 
    766     { "playlist_items_count", vlcInstance_playlist_items_count, METH_VARARGS, 
    767       "playlist_items_count() -> int   Return the number of items in the playlist"}, 
    768     { "playlist_stop", vlcInstance_playlist_stop, METH_VARARGS, 
    769       "playlist_stop()             Stop the current stream"}, 
    770     { "playlist_next", vlcInstance_playlist_next, METH_VARARGS, 
    771       "playlist_next()             Play the next item"}, 
    772     { "playlist_prev", vlcInstance_playlist_prev, METH_VARARGS, 
    773       "playlist_prev()             Play the previous item"}, 
    774     { "playlist_clear", vlcInstance_playlist_clear, METH_VARARGS, 
    775       "playlist_clear()            Clear the playlist"}, 
    776     { "playlist_add", vlcInstance_playlist_add, METH_VARARGS, 
    777       "playlist_add(mrl=str, name=str, options=list) -> int  Add a new item to the playlist. options is a list of strings."}, 
    778     { "playlist_delete_item", vlcInstance_playlist_delete_item, METH_VARARGS, 
    779       "playlist_delete_item(id=int)   Delete the given item"}, 
    780     { "playlist_get_media_player", vlcInstance_playlist_get_media_player, METH_VARARGS, 
    781       "playlist_get_media_player() -> object   Return the current media instance"}, 
    782567    { "video_set_parent", vlcInstance_video_set_parent, METH_VARARGS, 
    783568      "video_set_parent(xid=int)       Set the parent xid/HWND/CGrafPort"}, 
    784     { "video_get_parent", vlcInstance_video_get_parent, METH_VARARGS, 
    785       "video_get_parent(xid=int)       Get the parent xid/HWND/CGrafPort"}, 
     569    { "video_get_parent", vlcInstance_video_get_parent, METH_NOARGS, 
     570      "video_get_parent() -> int       Get the parent xid/HWND/CGrafPort"}, 
    786571    { "video_set_size", vlcInstance_video_set_size, METH_VARARGS, 
    787572      "video_set_size(width=int, height=int)    Set the video width and height"}, 
    788     { "audio_toggle_mute", vlcInstance_audio_toggle_mute, METH_VARARGS, 
     573    { "audio_toggle_mute", vlcInstance_audio_toggle_mute, METH_NOARGS, 
    789574      "audio_toggle_mute()         Toggle the mute state"}, 
    790     { "audio_get_mute", vlcInstance_audio_get_mute, METH_VARARGS, 
     575    { "audio_get_mute", vlcInstance_audio_get_mute, METH_NOARGS, 
    791576      "audio_get_mute() -> int     Get the mute state"}, 
    792577    { "audio_set_mute", vlcInstance_audio_set_mute, METH_VARARGS, 
    793578      "audio_set_mute(state=int)         Set the mute state"}, 
    794     { "audio_get_volume", vlcInstance_audio_get_volume, METH_VARARGS, 
     579    { "audio_get_volume", vlcInstance_audio_get_volume, METH_NOARGS, 
    795580      "audio_get_volume() -> int   Get the audio volume"}, 
    796581    { "audio_set_volume", vlcInstance_audio_set_volume, METH_VARARGS, 
    797582      "audio_set_volume(volume=int)       Set the audio volume"}, 
    798     { "audio_get_channel", vlcInstance_audio_get_channel, METH_VARARGS, 
     583    { "audio_get_channel", vlcInstance_audio_get_channel, METH_NOARGS, 
    799584      "audio_get_channel() -> int  Get current audio channel" }, 
    800585    { "audio_set_channel", vlcInstance_audio_set_channel, METH_VARARGS, 
    …… 
    802587 
    803588    { "media_new", vlcInstance_media_new, METH_VARARGS, 
    804       "media_new(str) -> object   Create a media descriptor with the given mrl."}, 
     589      "media_new(str) -> object   Create a media object with the given mrl."}, 
     590 
     591    { "mediaplayer_new", vlcInstance_new_media_player, METH_NOARGS, 
     592      "mediaplayer_new() -> object   Create a media player."}, 
    805593 
    806594    { "vlm_add_broadcast", vlcInstance_vlm_add_broadcast, METH_VARARGS | METH_KEYWORDS, 
    …… 
    857645    0,                         /*tp_as_buffer*/ 
    858646    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 
    859     "VLC Instance(args)\n\nNote: if args is specified, the first arg is interpreted as an executable name to get the directory of the VLC plugins.",  /* tp_doc */ 
     647    "VLC Instance(args)",  /* tp_doc */ 
    860648    0,                     /* tp_traverse */ 
    861649    0,                     /* tp_clear */ 

  • bindings/python/vlc_media.c

    r66fc001 r241b228  
    11/***************************************************************************** 
    2  * vlc_mediadescriptor.c: vlc.MediaDescriptor binding 
     2 * vlc_media.c: vlc.Media binding 
    33 ***************************************************************************** 
    44 * Copyright (C) 2007 the VideoLAN team 
    …… 
    2424 
    2525/*********************************************************************** 
    26  * vlc.MediaDescriptor 
     26 * vlc.Media 
    2727 ***********************************************************************/ 
    2828 
     29static PyObject * 
     30vlcMedia_new( PyTypeObject *type, PyObject *args, PyObject *kwds ) 
     31{ 
     32    fprintf(stderr, "vlcMedia_new called\n"); 
     33    PyErr_SetString( PyExc_TypeError, "vlc.Media can be instanciated by itself. You should use vlc.Instance().media_new(mrl)." ); 
     34    return NULL; 
     35} 
     36 
    2937static void 
    30 vlcMediaDescriptor_dealloc( PyObject *self ) 
    31 { 
    32     libvlc_media_release( LIBVLC_MEDIADESCRIPTOR->p_md ); 
     38vlcMedia_dealloc( PyObject *self ) 
     39{ 
     40    libvlc_media_release( LIBVLC_MEDIA->p_media ); 
    3341    PyObject_DEL( self ); 
    3442} 
    3543 
    3644static PyObject * 
    37 vlcMediaDescriptor_add_option( PyObject *self, PyObject *args ) 
     45vlcMedia_add_option( PyObject *self, PyObject *args ) 
    3846{ 
    3947    libvlc_exception_t ex; 
    …… 
    4452 
    4553    LIBVLC_TRY; 
    46     libvlc_media_add_option( LIBVLC_MEDIADESCRIPTOR->p_md, psz_options, &ex); 
     54    libvlc_media_add_option( LIBVLC_MEDIA->p_media, psz_options, &ex); 
    4755    LIBVLC_EXCEPT; 
    4856    Py_INCREF( Py_None ); 
    …… 
    5159 
    5260static PyObject * 
    53 vlcMediaDescriptor_get_mrl( PyObject *self, PyObject *args ) 
     61vlcMedia_get_mrl( PyObject *self, PyObject *args ) 
    5462{ 
    5563    libvlc_exception_t ex; 
    …… 
    5866 
    5967    LIBVLC_TRY; 
    60     psz_mrl = libvlc_media_get_mrl( LIBVLC_MEDIADESCRIPTOR->p_md, &ex); 
     68    psz_mrl = libvlc_media_get_mrl( LIBVLC_MEDIA->p_media, &ex); 
    6169    LIBVLC_EXCEPT; 
    6270 
    …… 
    6775 
    6876static PyObject * 
    69 vlcMediaDescriptor_get_state( PyObject *self, PyObject *args ) 
     77vlcMedia_get_state( PyObject *self, PyObject *args ) 
    7078{ 
    7179    libvlc_exception_t ex; 
    …… 
    7381 
    7482    LIBVLC_TRY; 
    75     i_state = libvlc_media_get_state( LIBVLC_MEDIADESCRIPTOR->p_md, &ex); 
     83    i_state = libvlc_media_get_state( LIBVLC_MEDIA->p_media, &ex); 
    7684    LIBVLC_EXCEPT; 
    7785    /* FIXME: return the defined state constant */ 
    …… 
    8088 
    8189static PyObject * 
    82 vlcMediaDescriptor_add_tag( PyObject *self, PyObject *args ) 
    83 { 
    84     libvlc_exception_t ex; 
    85     char* psz_key; 
    86     char* psz_tag; 
    87  
    88     if( !PyArg_ParseTuple( args, "ss", &psz_key, &psz_tag ) ) 
    89         return NULL; 
    90  
    91     LIBVLC_TRY; 
    92     libvlc_media_add_tag( LIBVLC_MEDIADESCRIPTOR->p_md, psz_key, ( libvlc_tag_t )psz_tag, &ex ); 
    93     LIBVLC_EXCEPT; 
    94     Py_INCREF( Py_None ); 
    95     return Py_None; 
    96 } 
    97  
    98 static PyObject * 
    99 vlcMediaDescriptor_remove_tag( PyObject *self, PyObject *args ) 
    100 { 
    101     libvlc_exception_t ex; 
    102     char* psz_key; 
    103     char* psz_tag; 
    104  
    105     if( !PyArg_ParseTuple( args, "ss", &psz_key, &psz_tag ) ) 
    106         return NULL; 
    107  
    108     LIBVLC_TRY; 
    109     libvlc_media_remove_tag( LIBVLC_MEDIADESCRIPTOR->p_md, psz_key, ( libvlc_tag_t )psz_tag, &ex ); 
    110     LIBVLC_EXCEPT; 
    111     Py_INCREF( Py_None ); 
    112     return Py_None; 
    113 } 
    114  
    115 static PyObject * 
    116 vlcMediaDescriptor_tags_count_for_key( PyObject *self, PyObject *args ) 
    117 { 
    118     libvlc_exception_t ex; 
    119     char* psz_tag; 
    120     int i_ret; 
    121  
    122     if( !PyArg_ParseTuple( args, "s", &psz_tag ) ) 
    123         return NULL; 
    124  
    125     LIBVLC_TRY; 
    126     i_ret=libvlc_media_tags_count_for_key( LIBVLC_MEDIADESCRIPTOR->p_md, psz_tag, &ex ); 
    127     LIBVLC_EXCEPT; 
    128     return Py_BuildValue( "i", i_ret ); 
    129 } 
    130  
    131 static PyObject * 
    132 vlcMediaDescriptor_get_duration( PyObject *self, PyObject *args ) 
     90vlcMedia_get_duration( PyObject *self, PyObject *args ) 
    13391{ 
    13492    libvlc_exception_t ex; 
    13593    libvlc_time_t i_ret; 
    13694    LIBVLC_TRY; 
    137     i_ret = libvlc_media_get_duration( LIBVLC_MEDIADESCRIPTOR->p_md, &ex); 
     95    i_ret = libvlc_media_get_duration( LIBVLC_MEDIA->p_media, &ex); 
    13896    LIBVLC_EXCEPT; 
    13997    return Py_BuildValue( "L", i_ret ); 
    …… 
    14199 
    142100static PyObject * 
    143 vlcMediaDescriptor_media_player_new( PyObject *self, PyObject *args ) 
    144 { 
    145     libvlc_exception_t ex; 
    146     libvlc_media_player_t *p_mi; 
    147     vlcMediaInstance *p_ret; 
    148  
    149     LIBVLC_TRY; 
    150     p_mi = libvlc_media_player_new_from_media( LIBVLC_MEDIADESCRIPTOR->p_md, &ex); 
    151     LIBVLC_EXCEPT; 
    152  
    153     p_ret = PyObject_New( vlcMediaInstance, &vlcMediaInstance_Type ); 
    154     p_ret->p_mi = p_mi; 
     101vlcMedia_media_player_new( PyObject *self, PyObject *args ) 
     102{ 
     103    libvlc_exception_t ex; 
     104    libvlc_media_player_t *p_mp; 
     105    vlcMediaPlayer *p_ret; 
     106 
     107    LIBVLC_TRY; 
     108    p_mp = libvlc_media_player_new_from_media( LIBVLC_MEDIA->p_media, &ex); 
     109    LIBVLC_EXCEPT; 
     110 
     111    p_ret = PyObject_New( vlcMediaPlayer, &vlcMediaPlayer_Type ); 
     112    p_ret->p_mp = p_mp; 
    155113    Py_INCREF( p_ret ); /* Ah bon ? */ 
    156114    return ( PyObject * )p_ret; 
    …… 
    158116 
    159117static PyObject * 
    160 vlcMediaDescriptor_is_preparsed( PyObject *self, PyObject *args ) 
     118vlcMedia_is_preparsed( PyObject *self, PyObject *args ) 
    161119{ 
    162120    libvlc_exception_t ex; 
    163121    int i_ret; 
    164122    LIBVLC_TRY; 
    165     i_ret = libvlc_media_is_preparsed( LIBVLC_MEDIADESCRIPTOR->p_md, &ex); 
     123    i_ret = libvlc_media_is_preparsed( LIBVLC_MEDIA->p_media, &ex); 
    166124    LIBVLC_EXCEPT; 
    167125    return Py_BuildValue( "L", i_ret ); 
    …… 
    169127 
    170128static PyObject * 
    171 vlcMediaDescriptor_get_meta( PyObject *self, PyObject *args ) 
     129vlcMedia_get_meta( PyObject *self, PyObject *args ) 
    172130{ 
    173131    libvlc_exception_t ex; 
    …… 
    198156 
    199157    LIBVLC_TRY; 
    200     psz_ret = libvlc_media_get_meta( LIBVLC_MEDIADESCRIPTOR->p_md, i_index, &ex); 
     158    psz_ret = libvlc_media_get_meta( LIBVLC_MEDIA->p_media, i_index, &ex); 
    201159    LIBVLC_EXCEPT; 
    202160 
    …… 
    206164} 
    207165 
    208 static PyMethodDef vlcMediaDescriptor_methods[] = 
    209 { 
    210     { "add_option", vlcMediaDescriptor_add_option, METH_VARARGS, 
    211       "add_option(str) Add an option to the media descriptor." }, 
    212     { "get_mrl", vlcMediaDescriptor_get_mrl, METH_VARARGS, 
     166static PyMethodDef vlcMedia_methods[] = 
     167{ 
     168    { "add_option", vlcMedia_add_option, METH_VARARGS, 
     169      "add_option(str) Add an option to the media." }, 
     170    { "get_mrl", vlcMedia_get_mrl, METH_VARARGS, 
    213171      "get_mrl() -> str" }, 
    214     { "get_state", vlcMediaDescriptor_get_state, METH_VARARGS, 
     172    { "get_state", vlcMedia_get_state, METH_VARARGS, 
    215173      "get_state() -> int" }, 
    216     { "add_tag", vlcMediaDescriptor_add_tag, METH_VARARGS, 
    217       "add_tag(key=str, tag=str) Add tag to the media descriptor." }, 
    218     { "remove_tag", vlcMediaDescriptor_remove_tag, METH_VARARGS, 
    219       "remove_tag(key=str, tag=str) Remove tag from the media descriptor." }, 
    220     { "tags_count_for_key", vlcMediaDescriptor_tags_count_for_key, METH_VARARGS, 
    221       "tags_count_for_key(str) ." }, 
    222     { "get_duration", vlcMediaDescriptor_get_duration, METH_VARARGS, 
     174    { "get_duration", vlcMedia_get_duration, METH_VARARGS, 
    223175      "get_duration() -> int" }, 
    224     { "mediainstance_new", vlcMediaDescriptor_media_player_new, METH_VARARGS, 
    225       "mediainstance_new() -> vlc.MediaInstance   Create a Media Instance object from a Media Descriptor" }, 
    226     { "is_preparsed", vlcMediaDescriptor_is_preparsed, METH_VARARGS, 
     176    { "mediaplayer_new", vlcMedia_media_player_new, METH_VARARGS, 
     177      "mediaplayer_new() -> vlc.MediaPlayer   Create a MediaPlayer object from a Media" }, 
     178    { "is_preparsed", vlcMedia_is_preparsed, METH_VARARGS, 
    227179      "is_preparsed() -> int" }, 
    228     { "get_meta", vlcMediaDescriptor_get_meta, METH_VARARGS, 
    229       "get_meta(str) -> str   Read the meta of the media descriptor." }, 
     180    { "get_meta", vlcMedia_get_meta, METH_VARARGS, 
     181      "get_meta(str) -> str   Read the meta of the media." }, 
    230182     
    231183    { NULL }  /* Sentinel */ 
    232184}; 
    233185 
    234 static PyTypeObject vlcMediaDescriptor_Type = 
     186static PyTypeObject vlcMedia_Type = 
    235187{ 
    236188    PyObject_HEAD_INIT( NULL ) 
    237189    0,                         /*ob_size*/ 
    238     "vlc.MediaDescriptor",            /*tp_name*/ 
    239     sizeof( vlcMediaDescriptor_Type ),   /*tp_basicsize*/ 
     190    "vlc.Media",            /*tp_name*/ 
     191    sizeof( vlcMedia_Type ),   /*tp_basicsize*/ 
    240192    0,                         /*tp_itemsize*/ 
    241     vlcMediaDescriptor_dealloc, /*tp_dealloc*/ 
     193    vlcMedia_dealloc, /*tp_dealloc*/ 
    242194    0,                         /*tp_print*/ 
    243195    0,                         /*tp_getattr*/ 
    …… 
    255207    0,                         /*tp_as_buffer*/ 
    256208    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 
    257     "vlc.MediaDescriptor object.",  /* tp_doc */ 
     209    "vlc.Media object.",  /* tp_doc */ 
    258210    0,                        /* tp_traverse */ 
    259211    0,                        /* tp_clear */ 
    …… 
    262214    0,                         /* tp_iter */ 
    263215    0,                          /* tp_iternext */ 
    264     vlcMediaDescriptor_methods,          /* tp_methods */ 
     216    vlcMedia_methods,          /* tp_methods */ 
    265217    0,                         /* tp_members */ 
    266218    0,                         /* tp_getset */ 
    …… 
    272224    0,                         /* tp_init */ 
    273225    0,                         /* tp_alloc */ 
    274     0,                         /* tp_new */ 
     226    vlcMedia_new,              /* tp_new */ 
    275227}; 
    276228 

  • bindings/python/vlc_mediacontrol.c

    r6ee1e19 r241b228  
    4141    self = PyObject_New( MediaControl, &MediaControl_Type ); 
    4242 
     43    fprintf (stderr, "Instanciating mediacontrol\n"); 
    4344    if( PyArg_ParseTuple( args, "O", &py_param ) ) 
    4445    { 
    …… 
    109110MediaControl_dealloc( PyObject *self ) 
    110111{ 
     112    fprintf(stderr, "MC dealloc\n"); 
    111113    Py_DECREF( SELF->vlc_instance ); 
    112114    PyObject_DEL( self ); 
    …… 
    119121 
    120122    p_ret = SELF->vlc_instance; 
     123    Py_INCREF( p_ret ); 
     124    return ( PyObject * )p_ret; 
     125} 
     126 
     127static PyObject * 
     128MediaControl_get_mediaplayer( PyObject *self, PyObject *args ) 
     129{ 
     130    vlcMediaPlayer *p_ret; 
     131 
     132    p_ret = PyObject_New( vlcMediaPlayer, &vlcMediaPlayer_Type ); 
     133    p_ret->p_mp = mediacontrol_get_media_player( SELF->mc ); 
    121134    Py_INCREF( p_ret ); 
    122135    return ( PyObject * )p_ret; 
    …… 
    216229MediaControl_pause( PyObject *self, PyObject *args ) 
    217230{ 
    218     mediacontrol_Position *a_position; 
    219231    mediacontrol_Exception *exception = NULL; 
    220     PyObject *py_pos; 
    221  
    222     if( !PyArg_ParseTuple( args, "O", &py_pos ) ) 
    223     { 
    224         /* No argument. Use a default 0 value. */ 
    225         PyErr_Clear( ); 
    226         py_pos = NULL; 
    227     } 
    228     a_position = position_py_to_c( py_pos ); 
    229     if( !a_position ) 
    230         return NULL; 
    231  
    232     Py_BEGIN_ALLOW_THREADS 
    233     MC_TRY; 
    234     mediacontrol_pause( SELF->mc, a_position, exception ); 
    235     free( a_position ); 
     232 
     233    Py_BEGIN_ALLOW_THREADS 
     234    MC_TRY; 
     235    mediacontrol_pause( SELF->mc, exception ); 
    236236    Py_END_ALLOW_THREADS 
    237237    MC_EXCEPT; 
    …… 
    244244MediaControl_resume( PyObject *self, PyObject *args ) 
    245245{ 
    246     mediacontrol_Position *a_position; 
    247246    mediacontrol_Exception *exception = NULL; 
    248     PyObject *py_pos; 
    249  
    250     if( !PyArg_ParseTuple( args, "O", &py_pos ) ) 
    251     { 
    252         /* No argument. Use a default 0 value. */ 
    253         PyErr_Clear( ); 
    254         py_pos = NULL; 
    255     } 
    256     a_position = position_py_to_c( py_pos ); 
    257     if( !a_position ) 
    258         return NULL; 
    259  
    260     Py_BEGIN_ALLOW_THREADS 
    261     MC_TRY; 
    262     mediacontrol_start( SELF->mc, a_position, exception ); 
    263     free( a_position ); 
     247 
     248    Py_BEGIN_ALLOW_THREADS 
     249    MC_TRY; 
     250    mediacontrol_resume( SELF->mc, exception ); 
    264251    Py_END_ALLOW_THREADS 
    265252    MC_EXCEPT; 
    …… 
    272259MediaControl_stop( PyObject *self, PyObject *args ) 
    273260{ 
    274     mediacontrol_Position *a_position; 
    275261    mediacontrol_Exception *exception = NULL; 
    276     PyObject *py_pos; 
    277  
    278     if( !PyArg_ParseTuple( args, "O", &py_pos ) ) 
    279     { 
    280         /* No argument. Use a default 0 value. */ 
    281         PyErr_Clear( ); 
    282         py_pos = NULL; 
    283     } 
    284     a_position = position_py_to_c( py_pos ); 
    285     if( !a_position ) 
    286         return NULL; 
    287  
    288     Py_BEGIN_ALLOW_THREADS 
    289     MC_TRY; 
    290     mediacontrol_stop( SELF->mc, a_position, exception ); 
    291     free( a_position ); 
     262 
     263    Py_BEGIN_ALLOW_THREADS 
     264    MC_TRY; 
     265    mediacontrol_stop( SELF->mc, exception ); 
    292266    Py_END_ALLOW_THREADS 
    293267    MC_EXCEPT; 
    …… 
    306280 
    307281static PyObject * 
    308 MediaControl_playlist_add_item( PyObject *self, PyObject *args ) 
     282MediaControl_set_mrl( PyObject *self, PyObject *args ) 
    309283{ 
    310284    char *psz_file; 
    …… 
    316290    Py_BEGIN_ALLOW_THREADS 
    317291    MC_TRY; 
    318     mediacontrol_playlist_add_item( SELF->mc, psz_file, exception ); 
    319     Py_END_ALLOW_THREADS 
    320     MC_EXCEPT; 
    321  
    322     Py_INCREF( Py_None ); 
    323     return Py_None; 
    324 } 
    325  
    326 static PyObject * 
    327 MediaControl_playlist_clear( PyObject *self, PyObject *args ) 
    328 { 
     292    mediacontrol_set_mrl( SELF->mc, psz_file, exception ); 
     293    Py_END_ALLOW_THREADS 
     294    MC_EXCEPT; 
     295 
     296    Py_INCREF( Py_None ); 
     297    return Py_None; 
     298} 
     299 
     300static PyObject * 
     301MediaControl_get_mrl( PyObject *self, PyObject *args ) 
     302{ 
     303    PyObject *py_retval; 
     304    char* psz_file; 
    329305    mediacontrol_Exception *exception = NULL; 
    330306 
    331307    Py_BEGIN_ALLOW_THREADS 
    332308    MC_TRY; 
    333     mediacontrol_playlist_clear( SELF->mc, exception ); 
    334     Py_END_ALLOW_THREADS 
    335     MC_EXCEPT; 
    336  
    337     Py_INCREF( Py_None ); 
    338     return Py_None; 
    339 } 
    340  
    341 static PyObject * 
    342 MediaControl_playlist_get_list( PyObject *self, PyObject *args ) 
    343 { 
    344     PyObject *py_retval; 
    345     mediacontrol_Exception *exception = NULL; 
    346     mediacontrol_PlaylistSeq* pl; 
    347     Py_ssize_t i_index; 
    348     Py_ssize_t i_playlist_size; 
    349  
    350     Py_BEGIN_ALLOW_THREADS 
    351     MC_TRY; 
    352     pl = mediacontrol_playlist_get_list( SELF->mc, exception ); 
    353     Py_END_ALLOW_THREADS 
    354     MC_EXCEPT; 
    355  
    356     i_playlist_size = pl->size; 
    357  
    358     py_retval = PyList_New( i_playlist_size ); 
    359  
    360     for ( i_index = 0 ; i_index < i_playlist_size ; i_index++ ) 
    361     { 
    362         PyList_SetItem( py_retval, i_index, 
    363                         Py_BuildValue( "s", pl->data[i_index] ) ); 
    364     } 
    365     mediacontrol_PlaylistSeq__free( pl ); 
    366  
     309    psz_file = mediacontrol_get_mrl( SELF->mc, exception ); 
     310    Py_END_ALLOW_THREADS 
     311    MC_EXCEPT; 
     312 
     313    py_retval = Py_BuildValue( "s", psz_file ); 
     314    free( psz_file ); 
    367315    return py_retval; 
    368316} 
    369  
    370317 
    371318static PyObject * 
    …… 
    604551{ 
    605552    { "get_vlc_instance", MediaControl_get_vlc_instance, METH_VARARGS, 
    606       "get_vlc_instance( ) -> Instance    Get matching vlc.Instance." }, 
     553      "get_vlc_instance( ) -> Instance    Get embedded vlc.Instance." }, 
     554    { "get_mediaplayer", MediaControl_get_mediaplayer, METH_VARARGS, 
     555      "get_mediaplayer( ) -> MediaPlayer    Get embedded vlc.MediaPlayer." }, 
    607556    { "get_media_position", MediaControl_get_media_position, METH_VARARGS, 
    608557      "get_media_position( origin, key ) -> Position    Get current media position." }, 
    …… 
    619568    { "exit", MediaControl_exit, METH_VARARGS, 
    620569      "exit( )                     Exit the player" }, 
    621     { "playlist_add_item", MediaControl_playlist_add_item, METH_VARARGS, 
    622       "playlist_add_item( str )               Add an item to the playlist" }, 
    623     { "playlist_get_list", MediaControl_playlist_get_list, METH_VARARGS, 
    624       "playlist_get_list( ) -> list       Get the contents of the playlist" }, 
    625     { "playlist_clear", MediaControl_playlist_clear, METH_VARARGS, 
    626       "clear( )         Clear the playlist." }, 
     570    { "set_mrl", MediaControl_set_mrl, METH_VARARGS, 
     571      "set_mrl( str )               Set the file to be played" }, 
     572    { "get_mrl", MediaControl_get_mrl, METH_VARARGS, 
     573      "get_mrl( ) -> str       Get the played file" }, 
    627574    { "snapshot", MediaControl_snapshot, METH_VARARGS, 
    628575      "snapshot( Position ) -> dict        Take a snapshot" }, 

  • bindings/python/vlc_mediaplayer.c

    r66fc001 r241b228  
    11/***************************************************************************** 
    2  * vlc_input.c: vlc.Input binding 
     2 * vlc_mediaplayer.c: vlc.MediaPlayer binding 
    33 ***************************************************************************** 
    44 * Copyright (C) 2006 the VideoLAN team 
    …… 
    2828 
    2929static PyObject * 
    30 vlcMediaInstance_get_length( PyObject *self, PyObject *args ) 
     30vlcMediaPlayer_get_length( PyObject *self, PyObject *args ) 
    3131{ 
    3232    libvlc_exception_t ex; 
    3333    vlc_int64_t i_ret; 
    3434    LIBVLC_TRY; 
    35     i_ret = libvlc_media_player_get_length( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
     35    i_ret = libvlc_media_player_get_length( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
    3636    LIBVLC_EXCEPT; 
    3737    return Py_BuildValue( "L", i_ret ); 
    …… 
    3939 
    4040static PyObject * 
    41 vlcMediaInstance_get_time( PyObject *self, PyObject *args ) 
     41vlcMediaPlayer_get_time( PyObject *self, PyObject *args ) 
    4242{ 
    4343    libvlc_exception_t ex; 
    4444    vlc_int64_t i_ret; 
    4545    LIBVLC_TRY; 
    46     i_ret = libvlc_media_player_get_time( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
     46    i_ret = libvlc_media_player_get_time( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
    4747    LIBVLC_EXCEPT; 
    4848    return Py_BuildValue( "L", i_ret ); 
    …… 
    5050 
    5151static PyObject * 
    52 vlcMediaInstance_set_time( PyObject *self, PyObject *args ) 
     52vlcMediaPlayer_set_time( PyObject *self, PyObject *args ) 
    5353{ 
    5454    libvlc_exception_t ex; 
    …… 
    5959 
    6060    LIBVLC_TRY; 
    61     libvlc_media_player_set_time( LIBVLC_MEDIAINSTANCE->p_mi, i_time, &ex); 
    62     LIBVLC_EXCEPT; 
    63     Py_INCREF( Py_None ); 
    64     return Py_None; 
    65 } 
    66  
    67 static PyObject * 
    68 vlcMediaInstance_get_position( PyObject *self, PyObject *args ) 
     61    libvlc_media_player_set_time( LIBVLC_MEDIAPLAYER->p_mp, i_time, &ex); 
     62    LIBVLC_EXCEPT; 
     63    Py_INCREF( Py_None ); 
     64    return Py_None; 
     65} 
     66 
     67static PyObject * 
     68vlcMediaPlayer_get_position( PyObject *self, PyObject *args ) 
    6969{ 
    7070    libvlc_exception_t ex; 
    7171    float f_ret; 
    7272    LIBVLC_TRY; 
    73     f_ret = libvlc_media_player_get_position( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
     73    f_ret = libvlc_media_player_get_position( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
    7474    LIBVLC_EXCEPT; 
    7575    return Py_BuildValue( "f", f_ret ); 
    …… 
    7777 
    7878static PyObject * 
    79 vlcMediaInstance_set_position( PyObject *self, PyObject *args ) 
     79vlcMediaPlayer_set_position( PyObject *self, PyObject *args ) 
    8080{ 
    8181    libvlc_exception_t ex; 
    …… 
    8686 
    8787    LIBVLC_TRY; 
    88     libvlc_media_player_set_position( LIBVLC_MEDIAINSTANCE->p_mi, f_pos, &ex); 
    89     LIBVLC_EXCEPT; 
    90     Py_INCREF( Py_None ); 
    91     return Py_None; 
    92 } 
    93  
    94 static PyObject * 
    95 vlcMediaInstance_will_play( PyObject *self, PyObject *args ) 
    96 { 
    97     libvlc_exception_t ex; 
    98     int i_ret; 
    99     LIBVLC_TRY; 
    100     i_ret = libvlc_media_player_will_play( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
    101     LIBVLC_EXCEPT; 
    102     return Py_BuildValue( "i", i_ret ); 
    103 } 
    104  
    105 static PyObject * 
    106 vlcMediaInstance_get_rate( PyObject *self, PyObject *args ) 
     88    libvlc_media_player_set_position( LIBVLC_MEDIAPLAYER->p_mp, f_pos, &ex); 
     89    LIBVLC_EXCEPT; 
     90    Py_INCREF( Py_None ); 
     91    return Py_None; 
     92} 
     93 
     94static PyObject * 
     95vlcMediaPlayer_will_play( PyObject *self, PyObject *args ) 
     96{ 
     97    libvlc_exception_t ex; 
     98    int i_ret; 
     99    LIBVLC_TRY; 
     100    i_ret = libvlc_media_player_will_play( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
     101    LIBVLC_EXCEPT; 
     102    return Py_BuildValue( "i", i_ret ); 
     103} 
     104 
     105static PyObject * 
     106vlcMediaPlayer_get_rate( PyObject *self, PyObject *args ) 
    107107{ 
    108108    libvlc_exception_t ex; 
    109109    float f_ret; 
    110110    LIBVLC_TRY; 
    111     f_ret = libvlc_media_player_get_rate( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
     111    f_ret = libvlc_media_player_get_rate( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
    112112    LIBVLC_EXCEPT; 
    113113    return Py_BuildValue( "f", f_ret ); 
    …… 
    115115 
    116116static PyObject * 
    117 vlcMediaInstance_set_rate( PyObject *self, PyObject *args ) 
     117vlcMediaPlayer_set_rate( PyObject *self, PyObject *args ) 
    118118{ 
    119119    libvlc_exception_t ex; 
    …… 
    124124 
    125125    LIBVLC_TRY; 
    126     libvlc_media_player_set_rate( LIBVLC_MEDIAINSTANCE->p_mi, f_rate, &ex); 
    127     LIBVLC_EXCEPT; 
    128     Py_INCREF( Py_None ); 
    129     return Py_None; 
    130 } 
    131  
    132 static PyObject * 
    133 vlcMediaInstance_get_state( PyObject *self, PyObject *args ) 
    134 { 
    135     libvlc_exception_t ex; 
    136     int i_ret; 
    137     LIBVLC_TRY; 
    138     i_ret = libvlc_media_player_get_state( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
    139     LIBVLC_EXCEPT; 
    140     return Py_BuildValue( "i", i_ret ); 
    141 } 
    142  
    143 static PyObject * 
    144 vlcMediaInstance_has_vout( PyObject *self, PyObject *args ) 
    145 { 
    146     libvlc_exception_t ex; 
    147     int i_ret; 
    148     LIBVLC_TRY; 
    149     i_ret = libvlc_media_player_has_vout( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
    150     LIBVLC_EXCEPT; 
    151     return Py_BuildValue( "i", i_ret ); 
    152 } 
    153  
    154 static PyObject * 
    155 vlcMediaInstance_get_fps( PyObject *self, PyObject *args ) 
     126    libvlc_media_player_set_rate( LIBVLC_MEDIAPLAYER->p_mp, f_rate, &ex); 
     127    LIBVLC_EXCEPT; 
     128    Py_INCREF( Py_None ); 
     129    return Py_None; 
     130} 
     131 
     132static PyObject * 
     133vlcMediaPlayer_get_state( PyObject *self, PyObject *args ) 
     134{ 
     135    libvlc_exception_t ex; 
     136    int i_ret; 
     137    LIBVLC_TRY; 
     138    i_ret = libvlc_media_player_get_state( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
     139    LIBVLC_EXCEPT; 
     140    return Py_BuildValue( "i", i_ret ); 
     141} 
     142 
     143static PyObject * 
     144vlcMediaPlayer_has_vout( PyObject *self, PyObject *args ) 
     145{ 
     146    libvlc_exception_t ex; 
     147    int i_ret; 
     148    LIBVLC_TRY; 
     149    i_ret = libvlc_media_player_has_vout( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
     150    LIBVLC_EXCEPT; 
     151    return Py_BuildValue( "i", i_ret ); 
     152} 
     153 
     154static PyObject * 
     155vlcMediaPlayer_get_fps( PyObject *self, PyObject *args ) 
    156156{ 
    157157    libvlc_exception_t ex; 
    158158    float f_ret; 
    159159    LIBVLC_TRY; 
    160     f_ret = libvlc_media_player_get_fps( LIBVLC_MEDIAINSTANCE->p_mi, &ex); 
     160    f_ret = libvlc_media_player_get_fps( LIBVLC_MEDIAPLAYER->p_mp, &ex); 
    161161    LIBVLC_EXCEPT; 
    162162    return Py_BuildValue( "f", f_ret ); 
    …… 
    164164 
    165165static PyObject * 
    166 vlcMediaInstance_audio_get_track( PyObject *self, PyObject *args ) 
    167 { 
    168     libvlc_exception_t ex; 
    169     int i_ret; 
    170  
    171     LIBVLC_TRY; 
    172     i_ret = libvlc_audio_get_track( LIBVLC_MEDIAINSTANCE->p_mi, &ex ); 
    173     LIBVLC_EXCEPT; 
    174     return Py_BuildValue( "i", i_ret ); 
    175 } 
    176  
    177 static PyObject * 
    178 vlcMediaInstance_audio_set_track( PyObject *self, PyObject *args ) 
     166vlcMediaPlayer_audio_get_track( PyObject *self, PyObject *args ) 
     167{