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

   1 /*****************************************************************************
   2  * vlc_instance.c: vlc.Instance binding
   3  *****************************************************************************
   4  * Copyright (C) 2006,2007,2008,2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Olivier Aubert <olivier.aubert at liris.cnrs.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, "Instantiating\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(self) = 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(self) );
 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(self) ) );
 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(self), &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_audio_toggle_mute( PyObject *self, PyObject *args )
 142 {
 143     libvlc_exception_t ex;
 144     LIBVLC_TRY;
 145     libvlc_audio_toggle_mute( LIBVLC_INSTANCE(self), &ex );
 146     LIBVLC_EXCEPT;
 147     Py_INCREF( Py_None );
 148     return Py_None;
 149 }
 150
 151 static PyObject *
 152 vlcInstance_audio_get_mute( PyObject *self, PyObject *args )
 153 {
 154     libvlc_exception_t ex;
 155     int i_ret;
 156
 157     LIBVLC_TRY;
 158     i_ret = libvlc_audio_get_mute( LIBVLC_INSTANCE(self), &ex );
 159     LIBVLC_EXCEPT;
 160     return Py_BuildValue( "i", i_ret );
 161 }
 162
 163 static PyObject *
 164 vlcInstance_audio_set_mute( PyObject *self, PyObject *args )
 165 {
 166     libvlc_exception_t ex;
 167     int i_mute;
 168
 169     if( !PyArg_ParseTuple( args, "i", &i_mute ) )
 170         return NULL;
 171
 172     LIBVLC_TRY;
 173     libvlc_audio_set_mute( LIBVLC_INSTANCE(self), i_mute, &ex );
 174     LIBVLC_EXCEPT;
 175     Py_INCREF( Py_None );
 176     return Py_None;
 177 }
 178
 179 static PyObject *
 180 vlcInstance_audio_get_volume( PyObject *self, PyObject *args )
 181 {
 182     libvlc_exception_t ex;
 183     int i_ret;
 184
 185     LIBVLC_TRY;
 186     i_ret = libvlc_audio_get_volume( LIBVLC_INSTANCE(self), &ex );
 187     LIBVLC_EXCEPT;
 188     return Py_BuildValue( "i", i_ret );
 189 }
 190
 191 static PyObject *
 192 vlcInstance_audio_set_volume( PyObject *self, PyObject *args )
 193 {
 194     libvlc_exception_t ex;
 195     int i_volume;
 196
 197     if( !PyArg_ParseTuple( args, "i", &i_volume ) )
 198         return NULL;
 199
 200     LIBVLC_TRY;
 201     libvlc_audio_set_volume( LIBVLC_INSTANCE(self), i_volume, &ex );
 202     LIBVLC_EXCEPT;
 203     Py_INCREF( Py_None );
 204     return Py_None;
 205 }
 206
 207 static PyObject *
 208 vlcInstance_audio_get_channel( PyObject *self, PyObject *args )
 209 {
 210     libvlc_exception_t ex;
 211     int i_ret;
 212
 213     LIBVLC_TRY;
 214     i_ret = libvlc_audio_get_channel( LIBVLC_INSTANCE(self), &ex );
 215     LIBVLC_EXCEPT;
 216     return Py_BuildValue( "i", i_ret );
 217 }
 218
 219 static PyObject *
 220 vlcInstance_audio_set_channel( PyObject *self, PyObject *args )
 221 {
 222     libvlc_exception_t ex;
 223     int i_channel;
 224
 225     if( !PyArg_ParseTuple( args, "i", &i_channel ) )
 226         return NULL;
 227
 228     LIBVLC_TRY;
 229     libvlc_audio_set_channel( LIBVLC_INSTANCE(self), i_channel, &ex );
 230     LIBVLC_EXCEPT;
 231     Py_INCREF( Py_None );
 232     return Py_None;
 233 }
 234
 235 /* vlm_add_broadcast : name, input MRL, output MRL
 236    Keywords: options, enable, loop */
 237 static PyObject *
 238 vlcInstance_vlm_add_broadcast( PyObject *self, PyObject *args, PyObject *kwds )
 239 {
 240     libvlc_exception_t ex;
 241     static char *kwlist[] = { "name", "input", "output",
 242                               "options", "enable", "loop", NULL};
 243     char* psz_name = NULL;
 244     char* psz_input = NULL;
 245     char* psz_output = NULL;
 246     PyObject* py_options = NULL;
 247     int i_enable = 1;
 248     int i_loop = 0;
 249     int i_size = 0;
 250     char** ppsz_args = NULL;
 251
 252     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist,
 253                                       &psz_name,
 254                       &psz_input, &psz_output,
 255                       &py_options, &i_enable, &i_loop ) )
 256         return NULL;
 257
 258     if( py_options )
 259     {
 260         i_size = pyoptions_to_args( py_options, &ppsz_args );
 261     }
 262
 263     LIBVLC_TRY;
 264     libvlc_vlm_add_broadcast( LIBVLC_INSTANCE(self),
 265                               psz_name, psz_input, psz_output,
 266                               i_size, ppsz_args, i_enable, i_loop, &ex);
 267     free_args( i_size, ppsz_args );
 268     LIBVLC_EXCEPT;
 269     Py_INCREF( Py_None );
 270     return Py_None;
 271 }
 272
 273 static PyObject *
 274 vlcInstance_vlm_del_media( PyObject *self, PyObject *args )
 275 {
 276     libvlc_exception_t ex;
 277     char* psz_name;
 278
 279     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 280         return NULL;
 281
 282     LIBVLC_TRY;
 283     libvlc_vlm_del_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 284     LIBVLC_EXCEPT;
 285     Py_INCREF( Py_None );
 286     return Py_None;
 287 }
 288
 289 static PyObject *
 290 vlcInstance_vlm_set_enabled( PyObject *self, PyObject *args )
 291 {
 292     libvlc_exception_t ex;
 293     char* psz_name;
 294     int i_enabled;
 295
 296     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_enabled ) )
 297         return NULL;
 298
 299     LIBVLC_TRY;
 300     libvlc_vlm_set_enabled( LIBVLC_INSTANCE(self), psz_name, i_enabled, &ex);
 301     LIBVLC_EXCEPT;
 302     Py_INCREF( Py_None );
 303     return Py_None;
 304 }
 305
 306 static PyObject *
 307 vlcInstance_vlm_set_output( PyObject *self, PyObject *args )
 308 {
 309     libvlc_exception_t ex;
 310     char* psz_name;
 311     char* psz_output;
 312
 313     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_output ) )
 314         return NULL;
 315
 316     LIBVLC_TRY;
 317     libvlc_vlm_set_output( LIBVLC_INSTANCE(self), psz_name, psz_output, &ex);
 318     LIBVLC_EXCEPT;
 319     Py_INCREF( Py_None );
 320     return Py_None;
 321 }
 322
 323 static PyObject *
 324 vlcInstance_vlm_set_input( PyObject *self, PyObject *args )
 325 {
 326     libvlc_exception_t ex;
 327     char* psz_name;
 328     char* psz_input;
 329
 330     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
 331         return NULL;
 332
 333     LIBVLC_TRY;
 334     libvlc_vlm_set_input( LIBVLC_INSTANCE(self), psz_name, psz_input, &ex);
 335     LIBVLC_EXCEPT;
 336     Py_INCREF( Py_None );
 337     return Py_None;
 338 }
 339
 340 static PyObject *
 341 vlcInstance_vlm_add_input( PyObject *self, PyObject *args )
 342 {
 343     libvlc_exception_t ex;
 344     char* psz_name;
 345     char* psz_input;
 346
 347     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
 348         return NULL;
 349
 350     LIBVLC_TRY;
 351     libvlc_vlm_add_input( LIBVLC_INSTANCE(self), psz_name, psz_input, &ex);
 352     LIBVLC_EXCEPT;
 353     Py_INCREF( Py_None );
 354     return Py_None;
 355 }
 356
 357 static PyObject *
 358 vlcInstance_vlm_set_loop( PyObject *self, PyObject *args )
 359 {
 360     libvlc_exception_t ex;
 361     char* psz_name;
 362     int i_loop;
 363
 364     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_loop ) )
 365         return NULL;
 366
 367     LIBVLC_TRY;
 368     libvlc_vlm_set_loop( LIBVLC_INSTANCE(self), psz_name, i_loop, &ex);
 369     LIBVLC_EXCEPT;
 370     Py_INCREF( Py_None );
 371     return Py_None;
 372 }
 373
 374 static PyObject *
 375 vlcInstance_vlm_change_media( PyObject *self, PyObject *args, PyObject *kwds )
 376 {
 377     libvlc_exception_t ex;
 378     static char *kwlist[] = { "name", "input", "output",
 379                               "options", "enable", "loop", NULL};
 380     char* psz_name = NULL;
 381     char* psz_input = NULL;
 382     char* psz_output = NULL;
 383     PyObject* py_options = NULL;
 384     int i_enable = 1;
 385     int i_loop = 0;
 386     int i_size = 0;
 387     char** ppsz_args = NULL;
 388
 389     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist,
 390                                       &psz_name,
 391                       &psz_input, &psz_output,
 392                       &py_options, &i_enable, &i_loop ) )
 393         return NULL;
 394
 395     if( py_options )
 396     {
 397         i_size = pyoptions_to_args( py_options, &ppsz_args );
 398     }
 399
 400     LIBVLC_TRY;
 401     libvlc_vlm_change_media( LIBVLC_INSTANCE(self),
 402                               psz_name, psz_input, psz_output,
 403                               i_size, ppsz_args, i_enable, i_loop, &ex);
 404     free_args( i_size, ppsz_args );
 405     LIBVLC_EXCEPT;
 406     Py_INCREF( Py_None );
 407     return Py_None;
 408 }
 409
 410 static PyObject *
 411 vlcInstance_vlm_play_media( PyObject *self, PyObject *args )
 412 {
 413     libvlc_exception_t ex;
 414     char* psz_name;
 415
 416     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 417         return NULL;
 418
 419     LIBVLC_TRY;
 420     libvlc_vlm_play_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 421     LIBVLC_EXCEPT;
 422     Py_INCREF( Py_None );
 423     return Py_None;
 424 }
 425
 426 static PyObject *
 427 vlcInstance_vlm_stop_media( PyObject *self, PyObject *args )
 428 {
 429     libvlc_exception_t ex;
 430     char* psz_name;
 431
 432     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 433         return NULL;
 434
 435     LIBVLC_TRY;
 436     libvlc_vlm_stop_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 437     LIBVLC_EXCEPT;
 438     Py_INCREF( Py_None );
 439     return Py_None;
 440 }
 441
 442 static PyObject *
 443 vlcInstance_vlm_pause_media( PyObject *self, PyObject *args )
 444 {
 445     libvlc_exception_t ex;
 446     char* psz_name;
 447
 448     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 449         return NULL;
 450
 451     LIBVLC_TRY;
 452     libvlc_vlm_pause_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 453     LIBVLC_EXCEPT;
 454     Py_INCREF( Py_None );
 455     return Py_None;
 456 }
 457
 458 static PyObject *
 459 vlcInstance_vlm_seek_media( PyObject *self, PyObject *args )
 460 {
 461     libvlc_exception_t ex;
 462     char* psz_name;
 463     float f_percentage;
 464
 465     if( !PyArg_ParseTuple( args, "sf", &psz_name, &f_percentage ) )
 466         return NULL;
 467
 468     LIBVLC_TRY;
 469     libvlc_vlm_seek_media( LIBVLC_INSTANCE(self), psz_name, f_percentage, &ex);
 470     LIBVLC_EXCEPT;
 471     Py_INCREF( Py_None );
 472     return Py_None;
 473 }
 474
 475 static PyObject *
 476 vlcInstance_vlm_show_media( PyObject *self, PyObject *args )
 477 {
 478     libvlc_exception_t ex;
 479     char* psz_name;
 480     char* psz_ret;
 481     PyObject* o_ret;
 482
 483     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 484         return NULL;
 485     LIBVLC_TRY;
 486     psz_ret = libvlc_vlm_show_media( LIBVLC_INSTANCE(self), psz_name, &ex );
 487     LIBVLC_EXCEPT;
 488     o_ret = Py_BuildValue( "s", psz_ret );
 489     free( psz_ret );
 490     return o_ret;
 491 }
 492
 493 static PyObject *
 494 vlcInstance_media_new( PyObject *self, PyObject *args )
 495 {
 496     libvlc_exception_t ex;
 497     libvlc_media_t *p_media;
 498     char* psz_mrl = NULL;
 499     vlcMedia *p_ret;
 500
 501     if( !PyArg_ParseTuple( args, "s", &psz_mrl ) )
 502         return NULL;
 503
 504     LIBVLC_TRY;
 505     p_media = libvlc_media_new( LIBVLC_INSTANCE(self), psz_mrl, &ex );
 506     LIBVLC_EXCEPT;
 507
 508     p_ret = PyObject_New( vlcMedia, &vlcMedia_Type );
 509     p_ret->p_media = p_media;
 510     Py_INCREF( p_ret ); /* Ah bon ? */
 511     return ( PyObject * )p_ret;
 512 }
 513
 514 /* Method table */
 515 static PyMethodDef vlcInstance_methods[] =
 516 {
 517     { "get_vlc_id", vlcInstance_get_vlc_id, METH_NOARGS,
 518       "get_vlc_id( ) -> int        Get the instance id."},
 519     { "audio_toggle_mute", vlcInstance_audio_toggle_mute, METH_NOARGS,
 520       "audio_toggle_mute()         Toggle the mute state"},
 521     { "audio_get_mute", vlcInstance_audio_get_mute, METH_NOARGS,
 522       "audio_get_mute() -> int     Get the mute state"},
 523     { "audio_set_mute", vlcInstance_audio_set_mute, METH_VARARGS,
 524       "audio_set_mute(state=int)         Set the mute state"},
 525     { "audio_get_volume", vlcInstance_audio_get_volume, METH_NOARGS,
 526       "audio_get_volume() -> int   Get the audio volume"},
 527     { "audio_set_volume", vlcInstance_audio_set_volume, METH_VARARGS,
 528       "audio_set_volume(volume=int)       Set the audio volume"},
 529     { "audio_get_channel", vlcInstance_audio_get_channel, METH_NOARGS,
 530       "audio_get_channel() -> int  Get current audio channel" },
 531     { "audio_set_channel", vlcInstance_audio_set_channel, METH_VARARGS,
 532       "audio_set_channel(int)      Set current audio channel" },
 533
 534     { "media_new", vlcInstance_media_new, METH_VARARGS,
 535       "media_new(str) -> object   Create a media object with the given mrl."},
 536
 537     { "mediaplayer_new", vlcInstance_new_media_player, METH_NOARGS,
 538       "mediaplayer_new() -> object   Create a media player."},
 539
 540     { "vlm_add_broadcast", vlcInstance_vlm_add_broadcast, METH_VARARGS | METH_KEYWORDS,
 541       "vlm_add_broadcast(name=str, input=str, output=str, options=list, enable=int, loop=int)   Add a new broadcast" },
 542     { "vlm_del_media", vlcInstance_vlm_del_media, METH_VARARGS,
 543       "vlm_del_media(name=str)    Delete a media" },
 544     { "vlm_set_enabled", vlcInstance_vlm_set_enabled, METH_VARARGS,
 545       "vlm_set_enabled(name=str, enabled=int)    Enable/disable a media" },
 546     { "vlm_set_output", vlcInstance_vlm_set_output, METH_VARARGS,
 547       "vlm_set_output(name=str, output=str)      Set the output" },
 548     { "vlm_set_input", vlcInstance_vlm_set_input, METH_VARARGS,
 549       "vlm_set_input(name=str, output=str)       Set the input" },
 550     { "vlm_add_input", vlcInstance_vlm_add_input, METH_VARARGS,
 551       "vlm_add_input(name=str, output=str)       Add a media's input MRL" },
 552     { "vlm_set_loop", vlcInstance_vlm_set_loop, METH_VARARGS,
 553       "vlm_set_loop(name=str, loop=int)          Change the looping value" },
 554     { "vlm_change_media", vlcInstance_vlm_change_media, METH_VARARGS | METH_KEYWORDS,
 555       "vlm_change_media(name=str, input=str, output=str, options=list, enable=int, loop=int)   Change the broadcast parameters" },
 556     { "vlm_play_media", vlcInstance_vlm_play_media, METH_VARARGS,
 557       "vlm_play_media(name=str)       Plays the named broadcast." },
 558     { "vlm_stop_media", vlcInstance_vlm_stop_media, METH_VARARGS,
 559       "vlm_stop_media(name=str)       Stops the named broadcast." },
 560     { "vlm_pause_media", vlcInstance_vlm_pause_media, METH_VARARGS,
 561       "vlm_pause_media(name=str)      Pauses the named broadcast." },
 562     { "vlm_seek_media", vlcInstance_vlm_seek_media, METH_VARARGS,
 563       "vlm_seek_media(name=str, percentage=float)  Seeks in the named broadcast." },
 564     { "vlm_show_media", vlcInstance_vlm_show_media, METH_VARARGS,
 565       "vlm_show_media(name=str)       Return information of the named broadcast." },
 566
 567     { NULL, NULL, 0, NULL },
 568 };
 569
 570 static PyTypeObject vlcInstance_Type =
 571 {
 572     PyObject_HEAD_INIT( NULL )
 573     0,                          /*ob_size*/
 574     "vlc.Instance",             /*tp_name*/
 575     sizeof( vlcInstance_Type ), /*tp_basicsize*/
 576     0,                          /*tp_itemsize*/
 577     ( destructor )vlcInstance_dealloc,      /*tp_dealloc*/
 578     0,                         /*tp_print*/
 579     0,                         /*tp_getattr*/
 580     0,                         /*tp_setattr*/
 581     0,                         /*tp_compare*/
 582     0,                         /*tp_repr*/
 583     0,                         /*tp_as_number*/
 584     0,                         /*tp_as_sequence*/
 585     0,                         /*tp_as_mapping*/
 586     0,                         /*tp_hash */
 587     0,                         /*tp_call*/
 588     0,                         /*tp_str*/
 589     0,                         /*tp_getattro*/
 590     0,                         /*tp_setattro*/
 591     0,                         /*tp_as_buffer*/
 592     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 593     "VLC Instance(args)",  /* tp_doc */
 594     0,                     /* tp_traverse */
 595     0,                     /* tp_clear */
 596     0,                     /* tp_richcompare */
 597     0,                     /* tp_weaklistoffset */
 598     0,                     /* tp_iter */
 599     0,                     /* tp_iternext */
 600     vlcInstance_methods,             /* tp_methods */
 601     0,             /* tp_members */
 602     0,                         /* tp_getset */
 603     0,                         /* tp_base */
 604     0,                         /* tp_dict */
 605     0,                         /* tp_descr_get */
 606     0,                         /* tp_descr_set */
 607     0,                         /* tp_dictoffset */
 608     0,                         /* tp_init */
 609     0,                         /* tp_alloc */
 610     vlcInstance_new,          /* tp_new */
 611 };