git.sesse.net Git - vlc/blob - bindings/python/vlc_instance.c

   1 /*****************************************************************************
   2  * vlc_instance.c: vlc.Instance binding
   3  *****************************************************************************
   4  * Copyright (C) 2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Olivier Aubert <oaubert at bat710.univ-lyon1.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23 #include "vlcglue.h"
  24
  25 /* Helper functions */
  26 static Py_ssize_t
  27 pyoptions_to_args(PyObject *py_options, char*** pppsz_args)
  28 {
  29     Py_ssize_t i_size;
  30     Py_ssize_t  i_index;
  31
  32     Py_INCREF( py_options );
  33     if( ! PySequence_Check( py_options ) )
  34     {
  35         PyErr_SetString( PyExc_TypeError, "Parameter must be a sequence." );
  36         return -1;
  37     }
  38     i_size = PySequence_Size( py_options );
  39
  40     char **ppsz_args = *pppsz_args = malloc( ( i_size + 1 ) * sizeof( char * ) );
  41
  42     if( ! ppsz_args )
  43     {
  44         PyErr_SetString( PyExc_MemoryError, "Out of memory" );
  45         return -1;
  46     }
  47
  48     for ( i_index = 0; i_index < i_size; i_index++ )
  49     {
  50         ppsz_args[i_index] =
  51             strdup( PyString_AsString( PyObject_Str(
  52                                            PySequence_GetItem( py_options,
  53                                                                i_index ) ) ) );
  54     }
  55     ppsz_args[i_size] = NULL;
  56     Py_DECREF( py_options );
  57     return i_size;
  58 }
  59
  60 static void
  61 free_args(int i_size, char** ppsz_args)
  62 {
  63     int i_index;
  64
  65     for ( i_index = 0; i_index < i_size; i_index++ )
  66         free( ppsz_args[i_index] );
  67     free( ppsz_args );
  68 }
  69
  70 /*****************************************************************************
  71  * Instance object implementation
  72  *****************************************************************************/
  73
  74 static PyObject *
  75 vlcInstance_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
  76 {
  77     vlcInstance *self;
  78     libvlc_exception_t ex;
  79     PyObject* py_list = NULL;
  80     char** ppsz_args = NULL;
  81     int i_size = 0;
  82
  83     fprintf(stderr, "Instancianting\n");
  84     if( PyArg_ParseTuple( args, "|O", &py_list ) )
  85     {
  86         i_size = pyoptions_to_args( py_list, &ppsz_args );
  87         if( i_size < 0 )
  88             return NULL;
  89     }
  90     else
  91     {
  92         /* No arguments were given. Clear the exception raised
  93            by PyArg_ParseTuple. */
  94         PyErr_Clear( );
  95     }
  96
  97     self = PyObject_New( vlcInstance, &vlcInstance_Type );
  98
  99     Py_BEGIN_ALLOW_THREADS
 100     LIBVLC_TRY
 101     LIBVLC_INSTANCE->p_instance = libvlc_new( i_size, ppsz_args, &ex );
 102     free_args( i_size, ppsz_args );
 103     LIBVLC_EXCEPT
 104     Py_END_ALLOW_THREADS
 105
 106     Py_INCREF( self );
 107     return ( PyObject * )self;
 108 }
 109
 110 static void
 111 vlcInstance_dealloc( PyObject *self )
 112 {
 113     libvlc_release( LIBVLC_INSTANCE->p_instance );
 114     PyObject_DEL( self );
 115 }
 116
 117 static PyObject *
 118 vlcInstance_get_vlc_id( PyObject *self, PyObject *args )
 119 {
 120     return Py_BuildValue( "i", libvlc_get_vlc_id( LIBVLC_INSTANCE->p_instance ) );
 121 }
 122
 123 static PyObject *
 124 vlcInstance_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;
 136     Py_INCREF( p_ret ); /* Ah bon ? */
 137     return ( PyObject * )p_ret;
 138 }
 139
 140 static PyObject *
 141 vlcInstance_video_set_parent( PyObject *self, PyObject *args )
 142 {
 143     libvlc_exception_t ex;
 144     int i_drawable;
 145
 146     if( !PyArg_ParseTuple( args, "i", &i_drawable ) )
 147         return NULL;
 148
 149     LIBVLC_TRY;
 150     libvlc_video_set_parent( LIBVLC_INSTANCE->p_instance, (libvlc_drawable_t) i_drawable, &ex );
 151     LIBVLC_EXCEPT;
 152
 153     Py_INCREF( Py_None );
 154     return Py_None;
 155 }
 156
 157 static PyObject *
 158 vlcInstance_video_get_parent( PyObject *self, PyObject *args )
 159 {
 160     libvlc_exception_t ex;
 161     libvlc_drawable_t i_ret;
 162
 163     LIBVLC_TRY;
 164     i_ret = libvlc_video_get_parent( LIBVLC_INSTANCE->p_instance, &ex );
 165     LIBVLC_EXCEPT;
 166
 167     return Py_BuildValue( "L", i_ret );
 168 }
 169
 170 static PyObject *
 171 vlcInstance_video_set_size( PyObject *self, PyObject *args )
 172 {
 173     libvlc_exception_t ex;
 174     int i_width;
 175     int i_height;
 176
 177     if( !PyArg_ParseTuple( args, "ii", &i_width, &i_height ) )
 178         return NULL;
 179
 180     LIBVLC_TRY;
 181     libvlc_video_set_size( LIBVLC_INSTANCE->p_instance, i_width, i_height, &ex );
 182     LIBVLC_EXCEPT;
 183
 184     Py_INCREF( Py_None );
 185     return Py_None;
 186 }
 187
 188 static PyObject *
 189 vlcInstance_audio_toggle_mute( PyObject *self, PyObject *args )
 190 {
 191     libvlc_exception_t ex;
 192     LIBVLC_TRY;
 193     libvlc_audio_toggle_mute( LIBVLC_INSTANCE->p_instance, &ex );
 194     LIBVLC_EXCEPT;
 195     Py_INCREF( Py_None );
 196     return Py_None;
 197 }
 198
 199 static PyObject *
 200 vlcInstance_audio_get_mute( PyObject *self, PyObject *args )
 201 {
 202     libvlc_exception_t ex;
 203     int i_ret;
 204
 205     LIBVLC_TRY;
 206     i_ret = libvlc_audio_get_mute( LIBVLC_INSTANCE->p_instance, &ex );
 207     LIBVLC_EXCEPT;
 208     return Py_BuildValue( "i", i_ret );
 209 }
 210
 211 static PyObject *
 212 vlcInstance_audio_set_mute( PyObject *self, PyObject *args )
 213 {
 214     libvlc_exception_t ex;
 215     int i_mute;
 216
 217     if( !PyArg_ParseTuple( args, "i", &i_mute ) )
 218         return NULL;
 219
 220     LIBVLC_TRY;
 221     libvlc_audio_set_mute( LIBVLC_INSTANCE->p_instance, i_mute, &ex );
 222     LIBVLC_EXCEPT;
 223     Py_INCREF( Py_None );
 224     return Py_None;
 225 }
 226
 227 static PyObject *
 228 vlcInstance_audio_get_volume( PyObject *self, PyObject *args )
 229 {
 230     libvlc_exception_t ex;
 231     int i_ret;
 232
 233     LIBVLC_TRY;
 234     i_ret = libvlc_audio_get_volume( LIBVLC_INSTANCE->p_instance, &ex );
 235     LIBVLC_EXCEPT;
 236     return Py_BuildValue( "i", i_ret );
 237 }
 238
 239 static PyObject *
 240 vlcInstance_audio_set_volume( PyObject *self, PyObject *args )
 241 {
 242     libvlc_exception_t ex;
 243     int i_volume;
 244
 245     if( !PyArg_ParseTuple( args, "i", &i_volume ) )
 246         return NULL;
 247
 248     LIBVLC_TRY;
 249     libvlc_audio_set_volume( LIBVLC_INSTANCE->p_instance, i_volume, &ex );
 250     LIBVLC_EXCEPT;
 251     Py_INCREF( Py_None );
 252     return Py_None;
 253 }
 254
 255 static PyObject *
 256 vlcInstance_audio_get_channel( PyObject *self, PyObject *args )
 257 {
 258     libvlc_exception_t ex;
 259     int i_ret;
 260
 261     LIBVLC_TRY;
 262     i_ret = libvlc_audio_get_channel( LIBVLC_INSTANCE->p_instance, &ex );
 263     LIBVLC_EXCEPT;
 264     return Py_BuildValue( "i", i_ret );
 265 }
 266
 267 static PyObject *
 268 vlcInstance_audio_set_channel( PyObject *self, PyObject *args )
 269 {
 270     libvlc_exception_t ex;
 271     int i_channel;
 272
 273     if( !PyArg_ParseTuple( args, "i", &i_channel ) )
 274         return NULL;
 275
 276     LIBVLC_TRY;
 277     libvlc_audio_set_channel( LIBVLC_INSTANCE->p_instance, i_channel, &ex );
 278     LIBVLC_EXCEPT;
 279     Py_INCREF( Py_None );
 280     return Py_None;
 281 }
 282
 283 /* vlm_add_broadcast : name, input MRL, output MRL
 284    Keywords: options, enable, loop */
 285 static PyObject *
 286 vlcInstance_vlm_add_broadcast( PyObject *self, PyObject *args, PyObject *kwds )
 287 {
 288     libvlc_exception_t ex;
 289     static char *kwlist[] = { "name", "input", "output",
 290                               "options", "enable", "loop", NULL};
 291     char* psz_name = NULL;
 292     char* psz_input = NULL;
 293     char* psz_output = NULL;
 294     PyObject* py_options = NULL;
 295     int i_enable = 1;
 296     int i_loop = 0;
 297     int i_size = 0;
 298     char** ppsz_args = NULL;
 299
 300     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist,
 301                                       &psz_name,
 302                       &psz_input, &psz_output,
 303                       &py_options, &i_enable, &i_loop ) )
 304         return NULL;
 305
 306     if( py_options )
 307     {
 308         i_size = pyoptions_to_args( py_options, &ppsz_args );
 309     }
 310
 311     LIBVLC_TRY;
 312     libvlc_vlm_add_broadcast( LIBVLC_INSTANCE->p_instance,
 313                               psz_name, psz_input, psz_output,
 314                               i_size, ppsz_args, i_enable, i_loop, &ex);
 315     free_args( i_size, ppsz_args );
 316     LIBVLC_EXCEPT;
 317     Py_INCREF( Py_None );
 318     return Py_None;
 319 }
 320
 321 static PyObject *
 322 vlcInstance_vlm_del_media( PyObject *self, PyObject *args )
 323 {
 324     libvlc_exception_t ex;
 325     char* psz_name;
 326
 327     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 328         return NULL;
 329
 330     LIBVLC_TRY;
 331     libvlc_vlm_del_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
 332     LIBVLC_EXCEPT;
 333     Py_INCREF( Py_None );
 334     return Py_None;
 335 }
 336
 337 static PyObject *
 338 vlcInstance_vlm_set_enabled( PyObject *self, PyObject *args )
 339 {
 340     libvlc_exception_t ex;
 341     char* psz_name;
 342     int i_enabled;
 343
 344     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_enabled ) )
 345         return NULL;
 346
 347     LIBVLC_TRY;
 348     libvlc_vlm_set_enabled( LIBVLC_INSTANCE->p_instance, psz_name, i_enabled, &ex);
 349     LIBVLC_EXCEPT;
 350     Py_INCREF( Py_None );
 351     return Py_None;
 352 }
 353
 354 static PyObject *
 355 vlcInstance_vlm_set_output( PyObject *self, PyObject *args )
 356 {
 357     libvlc_exception_t ex;
 358     char* psz_name;
 359     char* psz_output;
 360
 361     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_output ) )
 362         return NULL;
 363
 364     LIBVLC_TRY;
 365     libvlc_vlm_set_output( LIBVLC_INSTANCE->p_instance, psz_name, psz_output, &ex);
 366     LIBVLC_EXCEPT;
 367     Py_INCREF( Py_None );
 368     return Py_None;
 369 }
 370
 371 static PyObject *
 372 vlcInstance_vlm_set_input( PyObject *self, PyObject *args )
 373 {
 374     libvlc_exception_t ex;
 375     char* psz_name;
 376     char* psz_input;
 377
 378     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
 379         return NULL;
 380
 381     LIBVLC_TRY;
 382     libvlc_vlm_set_input( LIBVLC_INSTANCE->p_instance, psz_name, psz_input, &ex);
 383     LIBVLC_EXCEPT;
 384     Py_INCREF( Py_None );
 385     return Py_None;
 386 }
 387
 388 static PyObject *
 389 vlcInstance_vlm_add_input( PyObject *self, PyObject *args )
 390 {
 391     libvlc_exception_t ex;
 392     char* psz_name;
 393     char* psz_input;
 394
 395     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
 396         return NULL;
 397
 398     LIBVLC_TRY;
 399     libvlc_vlm_add_input( LIBVLC_INSTANCE->p_instance, psz_name, psz_input, &ex);
 400     LIBVLC_EXCEPT;
 401     Py_INCREF( Py_None );
 402     return Py_None;
 403 }
 404
 405 static PyObject *
 406 vlcInstance_vlm_set_loop( PyObject *self, PyObject *args )
 407 {
 408     libvlc_exception_t ex;
 409     char* psz_name;
 410     int i_loop;
 411
 412     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_loop ) )
 413         return NULL;
 414
 415     LIBVLC_TRY;
 416     libvlc_vlm_set_loop( LIBVLC_INSTANCE->p_instance, psz_name, i_loop, &ex);
 417     LIBVLC_EXCEPT;
 418     Py_INCREF( Py_None );
 419     return Py_None;
 420 }
 421
 422 static PyObject *
 423 vlcInstance_vlm_change_media( PyObject *self, PyObject *args, PyObject *kwds )
 424 {
 425     libvlc_exception_t ex;
 426     static char *kwlist[] = { "name", "input", "output",
 427                               "options", "enable", "loop", NULL};
 428     char* psz_name = NULL;
 429     char* psz_input = NULL;
 430     char* psz_output = NULL;
 431     PyObject* py_options = NULL;
 432     int i_enable = 1;
 433     int i_loop = 0;
 434     int i_size = 0;
 435     char** ppsz_args = NULL;
 436
 437     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist,
 438                                       &psz_name,
 439                       &psz_input, &psz_output,
 440                       &py_options, &i_enable, &i_loop ) )
 441         return NULL;
 442
 443     if( py_options )
 444     {
 445         i_size = pyoptions_to_args( py_options, &ppsz_args );
 446     }
 447
 448     LIBVLC_TRY;
 449     libvlc_vlm_change_media( LIBVLC_INSTANCE->p_instance,
 450                               psz_name, psz_input, psz_output,
 451                               i_size, ppsz_args, i_enable, i_loop, &ex);
 452     free_args( i_size, ppsz_args );
 453     LIBVLC_EXCEPT;
 454     Py_INCREF( Py_None );
 455     return Py_None;
 456 }
 457
 458 static PyObject *
 459 vlcInstance_vlm_play_media( PyObject *self, PyObject *args )
 460 {
 461     libvlc_exception_t ex;
 462     char* psz_name;
 463
 464     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 465         return NULL;
 466
 467     LIBVLC_TRY;
 468     libvlc_vlm_play_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
 469     LIBVLC_EXCEPT;
 470     Py_INCREF( Py_None );
 471     return Py_None;
 472 }
 473
 474 static PyObject *
 475 vlcInstance_vlm_stop_media( PyObject *self, PyObject *args )
 476 {
 477     libvlc_exception_t ex;
 478     char* psz_name;
 479
 480     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 481         return NULL;
 482
 483     LIBVLC_TRY;
 484     libvlc_vlm_stop_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
 485     LIBVLC_EXCEPT;
 486     Py_INCREF( Py_None );
 487     return Py_None;
 488 }
 489
 490 static PyObject *
 491 vlcInstance_vlm_pause_media( PyObject *self, PyObject *args )
 492 {
 493     libvlc_exception_t ex;
 494     char* psz_name;
 495
 496     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 497         return NULL;
 498
 499     LIBVLC_TRY;
 500     libvlc_vlm_pause_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
 501     LIBVLC_EXCEPT;
 502     Py_INCREF( Py_None );
 503     return Py_None;
 504 }
 505
 506 static PyObject *
 507 vlcInstance_vlm_seek_media( PyObject *self, PyObject *args )
 508 {
 509     libvlc_exception_t ex;
 510     char* psz_name;
 511     float f_percentage;
 512
 513     if( !PyArg_ParseTuple( args, "sf", &psz_name, &f_percentage ) )
 514         return NULL;
 515
 516     LIBVLC_TRY;
 517     libvlc_vlm_seek_media( LIBVLC_INSTANCE->p_instance, psz_name, f_percentage, &ex);
 518     LIBVLC_EXCEPT;
 519     Py_INCREF( Py_None );
 520     return Py_None;
 521 }
 522
 523 static PyObject *
 524 vlcInstance_vlm_show_media( PyObject *self, PyObject *args )
 525 {
 526     libvlc_exception_t ex;
 527     char* psz_name;
 528     char* psz_ret;
 529     PyObject* o_ret;
 530
 531     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 532         return NULL;
 533     LIBVLC_TRY;
 534     psz_ret = libvlc_vlm_show_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex );
 535     LIBVLC_EXCEPT;
 536     o_ret = Py_BuildValue( "s", psz_ret );
 537     free( psz_ret );
 538     return o_ret;
 539 }
 540
 541 static PyObject *
 542 vlcInstance_media_new( PyObject *self, PyObject *args )
 543 {
 544     libvlc_exception_t ex;
 545     libvlc_media_t *p_media;
 546     char* psz_mrl = NULL;
 547     vlcMedia *p_ret;
 548
 549     if( !PyArg_ParseTuple( args, "s", &psz_mrl ) )
 550         return NULL;
 551
 552     LIBVLC_TRY;
 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;
 558     Py_INCREF( p_ret ); /* Ah bon ? */
 559     return ( PyObject * )p_ret;
 560 }
 561
 562 /* Method table */
 563 static PyMethodDef vlcInstance_methods[] =
 564 {
 565     { "get_vlc_id", vlcInstance_get_vlc_id, METH_NOARGS,
 566       "get_vlc_id( ) -> int        Get the instance id."},
 567     { "video_set_parent", vlcInstance_video_set_parent, METH_VARARGS,
 568       "video_set_parent(xid=int)       Set 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"},
 571     { "video_set_size", vlcInstance_video_set_size, METH_VARARGS,
 572       "video_set_size(width=int, height=int)    Set the video width and height"},
 573     { "audio_toggle_mute", vlcInstance_audio_toggle_mute, METH_NOARGS,
 574       "audio_toggle_mute()         Toggle the mute state"},
 575     { "audio_get_mute", vlcInstance_audio_get_mute, METH_NOARGS,
 576       "audio_get_mute() -> int     Get the mute state"},
 577     { "audio_set_mute", vlcInstance_audio_set_mute, METH_VARARGS,
 578       "audio_set_mute(state=int)         Set the mute state"},
 579     { "audio_get_volume", vlcInstance_audio_get_volume, METH_NOARGS,
 580       "audio_get_volume() -> int   Get the audio volume"},
 581     { "audio_set_volume", vlcInstance_audio_set_volume, METH_VARARGS,
 582       "audio_set_volume(volume=int)       Set the audio volume"},
 583     { "audio_get_channel", vlcInstance_audio_get_channel, METH_NOARGS,
 584       "audio_get_channel() -> int  Get current audio channel" },
 585     { "audio_set_channel", vlcInstance_audio_set_channel, METH_VARARGS,
 586       "audio_set_channel(int)      Set current audio channel" },
 587
 588     { "media_new", vlcInstance_media_new, METH_VARARGS,
 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."},
 593
 594     { "vlm_add_broadcast", vlcInstance_vlm_add_broadcast, METH_VARARGS | METH_KEYWORDS,
 595       "vlm_add_broadcast(name=str, input=str, output=str, options=list, enable=int, loop=int)   Add a new broadcast" },
 596     { "vlm_del_media", vlcInstance_vlm_del_media, METH_VARARGS,
 597       "vlm_del_media(name=str)    Delete a media" },
 598     { "vlm_set_enabled", vlcInstance_vlm_set_enabled, METH_VARARGS,
 599       "vlm_set_enabled(name=str, enabled=int)    Enable/disable a media" },
 600     { "vlm_set_output", vlcInstance_vlm_set_output, METH_VARARGS,
 601       "vlm_set_output(name=str, output=str)      Set the output" },
 602     { "vlm_set_input", vlcInstance_vlm_set_input, METH_VARARGS,
 603       "vlm_set_input(name=str, output=str)       Set the input" },
 604     { "vlm_add_input", vlcInstance_vlm_add_input, METH_VARARGS,
 605       "vlm_add_input(name=str, output=str)       Add a media's input MRL" },
 606     { "vlm_set_loop", vlcInstance_vlm_set_loop, METH_VARARGS,
 607       "vlm_set_loop(name=str, loop=int)          Change the looping value" },
 608     { "vlm_change_media", vlcInstance_vlm_change_media, METH_VARARGS | METH_KEYWORDS,
 609       "vlm_change_media(name=str, input=str, output=str, options=list, enable=int, loop=int)   Change the broadcast parameters" },
 610     { "vlm_play_media", vlcInstance_vlm_play_media, METH_VARARGS,
 611       "vlm_play_media(name=str)       Plays the named broadcast." },
 612     { "vlm_stop_media", vlcInstance_vlm_stop_media, METH_VARARGS,
 613       "vlm_stop_media(name=str)       Stops the named broadcast." },
 614     { "vlm_pause_media", vlcInstance_vlm_pause_media, METH_VARARGS,
 615       "vlm_pause_media(name=str)      Pauses the named broadcast." },
 616     { "vlm_seek_media", vlcInstance_vlm_seek_media, METH_VARARGS,
 617       "vlm_seek_media(name=str, percentage=float)  Seeks in the named broadcast." },
 618     { "vlm_show_media", vlcInstance_vlm_show_media, METH_VARARGS,
 619       "vlm_show_media(name=str)       Return information of the named broadcast." },
 620
 621     { NULL, NULL, 0, NULL },
 622 };
 623
 624 static PyTypeObject vlcInstance_Type =
 625 {
 626     PyObject_HEAD_INIT( NULL )
 627     0,                          /*ob_size*/
 628     "vlc.Instance",             /*tp_name*/
 629     sizeof( vlcInstance_Type ), /*tp_basicsize*/
 630     0,                          /*tp_itemsize*/
 631     ( destructor )vlcInstance_dealloc,      /*tp_dealloc*/
 632     0,                         /*tp_print*/
 633     0,                         /*tp_getattr*/
 634     0,                         /*tp_setattr*/
 635     0,                         /*tp_compare*/
 636     0,                         /*tp_repr*/
 637     0,                         /*tp_as_number*/
 638     0,                         /*tp_as_sequence*/
 639     0,                         /*tp_as_mapping*/
 640     0,                         /*tp_hash */
 641     0,                         /*tp_call*/
 642     0,                         /*tp_str*/
 643     0,                         /*tp_getattro*/
 644     0,                         /*tp_setattro*/
 645     0,                         /*tp_as_buffer*/
 646     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 647     "VLC Instance(args)",  /* tp_doc */
 648     0,                     /* tp_traverse */
 649     0,                     /* tp_clear */
 650     0,                     /* tp_richcompare */
 651     0,                     /* tp_weaklistoffset */
 652     0,                     /* tp_iter */
 653     0,                     /* tp_iternext */
 654     vlcInstance_methods,             /* tp_methods */
 655     0,             /* tp_members */
 656     0,                         /* tp_getset */
 657     0,                         /* tp_base */
 658     0,                         /* tp_dict */
 659     0,                         /* tp_descr_get */
 660     0,                         /* tp_descr_set */
 661     0,                         /* tp_dictoffset */
 662     0,                         /* tp_init */
 663     0,                         /* tp_alloc */
 664     vlcInstance_new,          /* tp_new */
 665 };