3e5462a8e83ec7025440f2b5aa478b554879a478
[vlc.git] / 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 };