7bdd7313bc5ddce42242890bb89cb6dde2bb683f
[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     char** ppsz_args = *pppsz_args;
32     
33     ppsz_args = NULL;
34
35     Py_INCREF( py_options );
36     if( ! PySequence_Check( py_options ) )
37     {
38         PyErr_SetString( PyExc_TypeError, "Parameter must be a sequence." );
39         return -1;
40     }
41     i_size = PySequence_Size( py_options );
42     ppsz_args = malloc( ( i_size + 1 ) * sizeof( char * ) );
43     if( ! ppsz_args )
44     {
45         PyErr_SetString( PyExc_MemoryError, "Out of memory" );
46         return -1;
47     }
48
49     for ( i_index = 0; i_index < i_size; i_index++ )
50     {
51         ppsz_args[i_index] =
52             strdup( PyString_AsString( PyObject_Str(
53                                            PySequence_GetItem( py_options,
54                                                                i_index ) ) ) );
55     }
56     ppsz_args[i_size] = NULL;
57     Py_DECREF( py_options );
58     return i_size;
59 }
60
61 static void
62 free_args(int i_size, char** ppsz_args)
63 {
64     int i_index;
65
66     for ( i_index = 0; i_index < i_size; i_index++ )
67         if( ppsz_args[i_index] )
68             free(ppsz_args[i_index]);
69     free( ppsz_args );
70 }
71
72 /*****************************************************************************
73  * Instance object implementation
74  *****************************************************************************/
75
76 static PyObject *
77 vlcInstance_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
78 {
79     vlcInstance *self;
80     libvlc_exception_t ex;
81     PyObject* py_list = NULL;
82     char** ppsz_args = NULL;
83     int i_size = 0;
84
85     self = PyObject_New( vlcInstance, &vlcInstance_Type );
86
87
88     if( PyArg_ParseTuple( args, "O", &py_list ) )
89     {
90         i_size = pyoptions_to_args( py_list, &ppsz_args );
91         if( i_size < 0 )
92             return NULL;
93     }
94     else
95     {
96         /* No arguments were given. Clear the exception raised
97            by PyArg_ParseTuple. */
98         PyErr_Clear( );
99     }
100
101     Py_BEGIN_ALLOW_THREADS
102     LIBVLC_TRY
103     LIBVLC_INSTANCE->p_instance = libvlc_new( i_size, ppsz_args, &ex );
104     free_args( i_size, ppsz_args );
105     LIBVLC_EXCEPT
106     Py_END_ALLOW_THREADS
107
108     Py_INCREF( self );
109     return ( PyObject * )self;
110 }
111
112 static void
113 vlcInstance_dealloc( PyObject *self )
114 {
115     libvlc_exception_t ex;
116     libvlc_destroy( LIBVLC_INSTANCE->p_instance, &ex );
117     PyMem_DEL( self );
118 }
119
120 static PyObject *
121 vlcInstance_get_vlc_id( PyObject *self, PyObject *args )
122 {
123     return Py_BuildValue( "i", libvlc_get_vlc_id( LIBVLC_INSTANCE->p_instance ) );
124 }
125
126 /* Set loop variable */
127 static PyObject *
128 vlcInstance_playlist_loop( PyObject *self, PyObject *args )
129 {
130     libvlc_exception_t ex;
131     int i_loop = 0;
132
133     if( !PyArg_ParseTuple( args, "i", &i_loop ) )
134         return NULL;
135
136     LIBVLC_TRY;
137     libvlc_playlist_loop( LIBVLC_INSTANCE->p_instance, i_loop, &ex );
138     LIBVLC_EXCEPT;
139
140     Py_INCREF( Py_None );
141     return Py_None;
142 }
143
144 /* Playlist play. 2 parameters: i_id, the id to play
145    l_options: a list of options */
146 static PyObject *
147 vlcInstance_playlist_play( PyObject *self, PyObject *args )
148 {
149     libvlc_exception_t ex;
150     int i_id = -1;
151     PyObject *py_options = NULL;
152     int i_size = 0;
153     char** ppsz_args = NULL;
154
155     if( !PyArg_ParseTuple( args, "|iO", &i_id, &py_options ) )
156         return NULL;
157
158     if( py_options )
159     {        
160         i_size = pyoptions_to_args( py_options, &ppsz_args );
161     }
162
163     LIBVLC_TRY;
164     libvlc_playlist_play( LIBVLC_INSTANCE->p_instance, i_id, i_size, ppsz_args, &ex );
165     free_args( i_size, ppsz_args );
166     LIBVLC_EXCEPT;
167
168     Py_INCREF( Py_None );
169     return Py_None;
170 }
171
172 static PyObject *
173 vlcInstance_playlist_pause( PyObject *self, PyObject *args )
174 {
175     libvlc_exception_t ex;
176     LIBVLC_TRY;
177     libvlc_playlist_pause( LIBVLC_INSTANCE->p_instance, &ex );
178     LIBVLC_EXCEPT;
179     Py_INCREF( Py_None );
180     return Py_None;
181 }
182
183 static PyObject *
184 vlcInstance_playlist_isplaying( PyObject *self, PyObject *args )
185 {
186     libvlc_exception_t ex;
187     int i_ret;
188
189     LIBVLC_TRY;
190     i_ret = libvlc_playlist_isplaying( LIBVLC_INSTANCE->p_instance, &ex );
191     LIBVLC_EXCEPT;
192     return Py_BuildValue( "i", i_ret );
193 }
194
195 static PyObject *
196 vlcInstance_playlist_items_count( PyObject *self, PyObject *args )
197 {
198     libvlc_exception_t ex;
199     int i_ret;
200
201     LIBVLC_TRY;
202     i_ret = libvlc_playlist_items_count( LIBVLC_INSTANCE->p_instance, &ex );
203     LIBVLC_EXCEPT;
204     return Py_BuildValue( "i", i_ret );
205 }
206
207 static PyObject *
208 vlcInstance_playlist_stop( PyObject *self, PyObject *args )
209 {
210     libvlc_exception_t ex;
211     LIBVLC_TRY;
212     libvlc_playlist_stop( LIBVLC_INSTANCE->p_instance, &ex );
213     LIBVLC_EXCEPT;
214     Py_INCREF( Py_None );
215     return Py_None;
216 }
217
218 static PyObject *
219 vlcInstance_playlist_next( PyObject *self, PyObject *args )
220 {
221     libvlc_exception_t ex;
222     LIBVLC_TRY;
223     libvlc_playlist_next( LIBVLC_INSTANCE->p_instance, &ex );
224     LIBVLC_EXCEPT;
225     Py_INCREF( Py_None );
226     return Py_None;
227 }
228
229 static PyObject *
230 vlcInstance_playlist_prev( PyObject *self, PyObject *args )
231 {
232     libvlc_exception_t ex;
233     LIBVLC_TRY;
234     libvlc_playlist_prev( LIBVLC_INSTANCE->p_instance, &ex );
235     LIBVLC_EXCEPT;
236     Py_INCREF( Py_None );
237     return Py_None;
238 }
239
240 static PyObject *
241 vlcInstance_playlist_clear( PyObject *self, PyObject *args )
242 {
243     libvlc_exception_t ex;
244     LIBVLC_TRY;
245     libvlc_playlist_clear( LIBVLC_INSTANCE->p_instance, &ex );
246     LIBVLC_EXCEPT;
247     Py_INCREF( Py_None );
248     return Py_None;
249 }
250
251 /* Add a playlist item. Main parameter: URI.
252    Optional parameters: name, options */
253 static PyObject *
254 vlcInstance_playlist_add( PyObject *self, PyObject *args)
255 {
256     libvlc_exception_t ex;
257     int i_ret;
258     char* psz_uri = NULL;
259     char* psz_name = NULL;
260     PyObject *py_options = NULL;
261     int i_size = 0;
262     char** ppsz_args = NULL;
263
264     if( !PyArg_ParseTuple( args, "s|sO", &psz_uri, &psz_name, &py_options ) )
265         return NULL;
266
267     if( !psz_name )
268     {
269         /* Set a default name */
270         psz_name = strdup( psz_uri );
271     }
272
273     if( py_options )
274     {        
275         i_size = pyoptions_to_args( py_options, &ppsz_args );
276     }
277
278     LIBVLC_TRY;
279     if( ppsz_args )
280     {
281         i_ret = libvlc_playlist_add_extended( LIBVLC_INSTANCE->p_instance,
282                                               psz_uri,
283                                               psz_name,
284                                               i_size,
285                                               ppsz_args,
286                                               &ex );
287         free_args( i_size, ppsz_args );
288     }
289     else
290     {
291         i_ret = libvlc_playlist_add( LIBVLC_INSTANCE->p_instance,
292                                      psz_uri,
293                                      psz_name,
294                                      &ex );
295     }
296     LIBVLC_EXCEPT;
297
298     return Py_BuildValue( "i", i_ret );
299 }
300
301 static PyObject *
302 vlcInstance_playlist_delete_item( PyObject *self, PyObject *args )
303 {
304     libvlc_exception_t ex;
305     int i_id;
306     int i_ret;
307
308     if( !PyArg_ParseTuple( args, "i", &i_id ) )
309         return NULL;
310
311     LIBVLC_TRY;
312     i_ret = libvlc_playlist_delete_item( LIBVLC_INSTANCE->p_instance, i_id, &ex );
313     LIBVLC_EXCEPT;
314
315     return Py_BuildValue( "i", i_ret );
316 }
317
318 static PyObject *
319 vlcInstance_playlist_get_input( PyObject *self, PyObject *args )
320 {
321     libvlc_exception_t ex;
322     libvlc_input_t *p_input;
323     vlcInput *p_ret;
324
325     LIBVLC_TRY;
326     p_input = libvlc_playlist_get_input( LIBVLC_INSTANCE->p_instance, &ex );
327     LIBVLC_EXCEPT;
328
329     p_ret = PyObject_New( vlcInput, &vlcInput_Type );
330     p_ret->p_input = p_input;
331     Py_INCREF( p_ret ); /* Ah bon ? */
332     return ( PyObject * )p_ret;
333 }
334
335 static PyObject *
336 vlcInstance_video_set_parent( PyObject *self, PyObject *args )
337 {
338     libvlc_exception_t ex;
339     int i_drawable;
340
341     if( !PyArg_ParseTuple( args, "i", &i_drawable ) )
342         return NULL;
343
344     LIBVLC_TRY;
345     libvlc_video_set_parent( LIBVLC_INSTANCE->p_instance, (libvlc_drawable_t) i_drawable, &ex );
346     LIBVLC_EXCEPT;
347
348     Py_INCREF( Py_None );
349     return Py_None;
350 }
351
352 static PyObject *
353 vlcInstance_video_set_size( PyObject *self, PyObject *args )
354 {
355     libvlc_exception_t ex;
356     int i_width;
357     int i_height;
358
359     if( !PyArg_ParseTuple( args, "ii", &i_width, &i_height ) )
360         return NULL;
361
362     LIBVLC_TRY;
363     libvlc_video_set_size( LIBVLC_INSTANCE->p_instance, i_width, i_height, &ex );
364     LIBVLC_EXCEPT;
365
366     Py_INCREF( Py_None );
367     return Py_None;
368 }
369
370 static PyObject *
371 vlcInstance_audio_toggle_mute( PyObject *self, PyObject *args )
372 {
373     libvlc_exception_t ex;
374     LIBVLC_TRY;
375     libvlc_audio_toggle_mute( LIBVLC_INSTANCE->p_instance, &ex );
376     LIBVLC_EXCEPT;
377     Py_INCREF( Py_None );
378     return Py_None;
379 }
380
381 static PyObject *
382 vlcInstance_audio_get_mute( PyObject *self, PyObject *args )
383 {
384     libvlc_exception_t ex;
385     int i_ret;
386
387     LIBVLC_TRY;
388     i_ret = libvlc_audio_get_mute( LIBVLC_INSTANCE->p_instance, &ex );
389     LIBVLC_EXCEPT;
390     return Py_BuildValue( "i", i_ret );
391 }
392
393 static PyObject *
394 vlcInstance_audio_set_mute( PyObject *self, PyObject *args )
395 {
396     libvlc_exception_t ex;
397     int i_mute;
398
399     if( !PyArg_ParseTuple( args, "i", &i_mute ) )
400         return NULL;
401
402     LIBVLC_TRY;
403     libvlc_audio_set_mute( LIBVLC_INSTANCE->p_instance, i_mute, &ex );
404     LIBVLC_EXCEPT;
405     Py_INCREF( Py_None );
406     return Py_None;
407 }
408
409 static PyObject *
410 vlcInstance_audio_get_volume( PyObject *self, PyObject *args )
411 {
412     libvlc_exception_t ex;
413     int i_ret;
414
415     LIBVLC_TRY;
416     i_ret = libvlc_audio_get_volume( LIBVLC_INSTANCE->p_instance, &ex );
417     LIBVLC_EXCEPT;
418     return Py_BuildValue( "i", i_ret );
419 }
420
421 static PyObject *
422 vlcInstance_audio_set_volume( PyObject *self, PyObject *args )
423 {
424     libvlc_exception_t ex;
425     int i_volume;
426
427     if( !PyArg_ParseTuple( args, "i", &i_volume ) )
428         return NULL;
429
430     LIBVLC_TRY;
431     libvlc_audio_set_volume( LIBVLC_INSTANCE->p_instance, i_volume, &ex );
432     LIBVLC_EXCEPT;
433     Py_INCREF( Py_None );
434     return Py_None;
435 }
436
437 static PyObject *
438 vlcInstance_audio_get_channel( PyObject *self, PyObject *args )
439 {
440     libvlc_exception_t ex;
441     int i_ret;
442
443     LIBVLC_TRY;
444     i_ret = libvlc_audio_get_channel( LIBVLC_INSTANCE->p_instance, &ex );
445     LIBVLC_EXCEPT;
446     return Py_BuildValue( "i", i_ret );
447 }
448
449 static PyObject *
450 vlcInstance_audio_set_channel( PyObject *self, PyObject *args )
451 {
452     libvlc_exception_t ex;
453     int i_channel;
454
455     if( !PyArg_ParseTuple( args, "i", &i_channel ) )
456         return NULL;
457
458     LIBVLC_TRY;
459     libvlc_audio_set_channel( LIBVLC_INSTANCE->p_instance, i_channel, &ex );
460     LIBVLC_EXCEPT;
461     Py_INCREF( Py_None );
462     return Py_None;
463 }
464
465 /* vlm_add_broadcast : name, input MRL, output MRL
466    Keywords: options, enable, loop */
467 static PyObject *
468 vlcInstance_vlm_add_broadcast( PyObject *self, PyObject *args, PyObject *kwds )
469 {
470     libvlc_exception_t ex;
471     static char *kwlist[] = { "name", "input", "output", 
472                               "options", "enable", "loop", NULL};
473     char* psz_name = NULL;
474     char* psz_input = NULL;
475     char* psz_output = NULL;
476     PyObject* py_options = NULL;
477     int i_enable = 1;
478     int i_loop = 0;
479     int i_size = 0;
480     char** ppsz_args = NULL;
481
482     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist, 
483                                       &psz_name,
484                                       &psz_input, &psz_output,
485                                       &py_options, &i_enable, &i_loop ) )
486         return NULL;
487     
488     if( py_options )
489     {
490         i_size = pyoptions_to_args( py_options, &ppsz_args );
491     }
492    
493     LIBVLC_TRY;
494     libvlc_vlm_add_broadcast( LIBVLC_INSTANCE->p_instance, 
495                               psz_name, psz_input, psz_output,
496                               i_size, ppsz_args, i_enable, i_loop, &ex);
497     free_args( i_size, ppsz_args );
498     LIBVLC_EXCEPT;
499     Py_INCREF( Py_None );
500     return Py_None;
501 }
502
503 static PyObject *
504 vlcInstance_vlm_del_media( PyObject *self, PyObject *args )
505 {
506     libvlc_exception_t ex;
507     char* psz_name;
508
509     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
510         return NULL;
511
512     LIBVLC_TRY;
513     libvlc_vlm_del_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
514     LIBVLC_EXCEPT;
515     Py_INCREF( Py_None );
516     return Py_None;
517 }
518
519 static PyObject *
520 vlcInstance_vlm_set_enabled( PyObject *self, PyObject *args )
521 {
522     libvlc_exception_t ex;
523     char* psz_name;
524     int i_enabled;
525     
526     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_enabled ) )
527         return NULL;
528
529     LIBVLC_TRY;
530     libvlc_vlm_set_enabled( LIBVLC_INSTANCE->p_instance, psz_name, i_enabled, &ex);
531     LIBVLC_EXCEPT;
532     Py_INCREF( Py_None );
533     return Py_None;
534 }
535
536 static PyObject *
537 vlcInstance_vlm_set_output( PyObject *self, PyObject *args )
538 {
539     libvlc_exception_t ex;
540     char* psz_name;
541     char* psz_output;
542     
543     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_output ) )
544         return NULL;
545
546     LIBVLC_TRY;
547     libvlc_vlm_set_output( LIBVLC_INSTANCE->p_instance, psz_name, psz_output, &ex);
548     LIBVLC_EXCEPT;
549     Py_INCREF( Py_None );
550     return Py_None;
551 }
552
553 static PyObject *
554 vlcInstance_vlm_set_input( PyObject *self, PyObject *args )
555 {
556     libvlc_exception_t ex;
557     char* psz_name;
558     char* psz_input;
559     
560     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
561         return NULL;
562
563     LIBVLC_TRY;
564     libvlc_vlm_set_input( LIBVLC_INSTANCE->p_instance, psz_name, psz_input, &ex);
565     LIBVLC_EXCEPT;
566     Py_INCREF( Py_None );
567     return Py_None;
568 }
569
570 static PyObject *
571 vlcInstance_vlm_set_loop( PyObject *self, PyObject *args )
572 {
573     libvlc_exception_t ex;
574     char* psz_name;
575     int i_loop;
576     
577     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_loop ) )
578         return NULL;
579
580     LIBVLC_TRY;
581     libvlc_vlm_set_loop( LIBVLC_INSTANCE->p_instance, psz_name, i_loop, &ex);
582     LIBVLC_EXCEPT;
583     Py_INCREF( Py_None );
584     return Py_None;
585 }
586
587 static PyObject *
588 vlcInstance_vlm_change_media( PyObject *self, PyObject *args, PyObject *kwds )
589 {
590     libvlc_exception_t ex;
591     static char *kwlist[] = { "name", "input", "output", 
592                               "options", "enable", "loop", NULL};
593     char* psz_name = NULL;
594     char* psz_input = NULL;
595     char* psz_output = NULL;
596     PyObject* py_options = NULL;
597     int i_enable = 1;
598     int i_loop = 0;
599     int i_size = 0;
600     char** ppsz_args = NULL;
601
602     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist, 
603                                       &psz_name,
604                                       &psz_input, &psz_output,
605                                       &py_options, &i_enable, &i_loop ) )
606         return NULL;
607     
608     if( py_options )
609     {
610         i_size = pyoptions_to_args( py_options, &ppsz_args );
611     }
612    
613     LIBVLC_TRY;
614     libvlc_vlm_change_media( LIBVLC_INSTANCE->p_instance, 
615                               psz_name, psz_input, psz_output,
616                               i_size, ppsz_args, i_enable, i_loop, &ex);
617     free_args( i_size, ppsz_args );
618     LIBVLC_EXCEPT;
619     Py_INCREF( Py_None );
620     return Py_None;
621 }
622
623 static PyObject *
624 vlcInstance_vlm_play_media( PyObject *self, PyObject *args )
625 {
626     libvlc_exception_t ex;
627     char* psz_name;
628     
629     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
630         return NULL;
631
632     LIBVLC_TRY;
633     libvlc_vlm_play_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
634     LIBVLC_EXCEPT;
635     Py_INCREF( Py_None );
636     return Py_None;
637 }
638
639 static PyObject *
640 vlcInstance_vlm_stop_media( PyObject *self, PyObject *args )
641 {
642     libvlc_exception_t ex;
643     char* psz_name;
644
645     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
646         return NULL;
647
648     LIBVLC_TRY;
649     libvlc_vlm_stop_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
650     LIBVLC_EXCEPT;
651     Py_INCREF( Py_None );
652     return Py_None;
653 }
654
655 static PyObject *
656 vlcInstance_vlm_pause_media( PyObject *self, PyObject *args )
657 {
658     libvlc_exception_t ex;
659     char* psz_name;
660     
661     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
662         return NULL;
663
664     LIBVLC_TRY;
665     libvlc_vlm_pause_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex);
666     LIBVLC_EXCEPT;
667     Py_INCREF( Py_None );
668     return Py_None;
669 }
670
671 static PyObject *
672 vlcInstance_vlm_seek_media( PyObject *self, PyObject *args )
673 {
674     libvlc_exception_t ex;
675     char* psz_name;
676     float f_percentage;
677     
678     if( !PyArg_ParseTuple( args, "sf", &psz_name, &f_percentage ) )
679         return NULL;
680
681     LIBVLC_TRY;
682     libvlc_vlm_seek_media( LIBVLC_INSTANCE->p_instance, psz_name, f_percentage, &ex);
683     LIBVLC_EXCEPT;
684     Py_INCREF( Py_None );
685     return Py_None;
686 }
687
688 static PyObject *
689 vlcInstance_vlm_show_media( PyObject *self, PyObject *args )
690 {
691     libvlc_exception_t ex;
692     char* psz_name;
693     char* psz_ret;
694     PyObject* o_ret;
695
696     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
697         return NULL;
698     LIBVLC_TRY;
699     psz_ret = libvlc_vlm_show_media( LIBVLC_INSTANCE->p_instance, psz_name, &ex );
700     LIBVLC_EXCEPT;
701     o_ret = Py_BuildValue( "s", psz_ret );
702     free( psz_ret );
703     return o_ret;
704 }
705
706 /* Method table */
707 static PyMethodDef vlcInstance_methods[] =
708 {
709     { "get_vlc_id", vlcInstance_get_vlc_id, METH_VARARGS,
710       "get_vlc_id( ) -> int        Get the instance id."},
711     { "playlist_loop", vlcInstance_playlist_loop, METH_VARARGS,
712       "playlist_loop(bool)         Set loop variable" },
713     { "playlist_play", vlcInstance_playlist_play, METH_VARARGS,
714       "playlist_play(id=int, options=list)   Play the given playlist item (-1 for current item) with optional options (a list of strings)" },
715     { "playlist_pause", vlcInstance_playlist_pause, METH_VARARGS,
716       "playlist_pause()            Pause the current stream"},
717     { "playlist_isplaying", vlcInstance_playlist_isplaying, METH_VARARGS,
718       "playlist_isplaying() -> int     Return True if the playlist if playing"},
719     { "playlist_items_count", vlcInstance_playlist_items_count, METH_VARARGS,
720       "playlist_items_count() -> int   Return the number of items in the playlist"},
721     { "playlist_stop", vlcInstance_playlist_stop, METH_VARARGS,
722       "playlist_stop()             Stop the current stream"},
723     { "playlist_next", vlcInstance_playlist_next, METH_VARARGS,
724       "playlist_next()             Play the next item"},
725     { "playlist_prev", vlcInstance_playlist_prev, METH_VARARGS,
726       "playlist_prev()             Play the previous item"},
727     { "playlist_clear", vlcInstance_playlist_clear, METH_VARARGS,
728       "playlist_clear()            Clear the playlist"},
729     { "playlist_add", vlcInstance_playlist_add, METH_VARARGS,
730       "playlist_add(mrl=str, name=str, options=list) -> int  Add a new item to the playlist. options is a list of strings."},
731     { "playlist_delete_item", vlcInstance_playlist_delete_item, METH_VARARGS,
732       "playlist_delete_item(id=int)   Delete the given item"},
733     { "playlist_get_input", vlcInstance_playlist_get_input, METH_VARARGS,
734       "playlist_get_input() -> object   Return the current input"},
735     { "video_set_parent", vlcInstance_video_set_parent, METH_VARARGS,
736       "video_set_parent(xid=int)       Set the parent xid or HWND"},
737     { "video_set_size", vlcInstance_video_set_size, METH_VARARGS,
738       "video_set_size(width=int, height=int)    Set the video width and height"},
739     { "audio_toggle_mute", vlcInstance_audio_toggle_mute, METH_VARARGS,
740       "audio_toggle_mute()         Toggle the mute state"},
741     { "audio_get_mute", vlcInstance_audio_get_mute, METH_VARARGS,
742       "audio_get_mute() -> int     Get the mute state"},
743     { "audio_set_mute", vlcInstance_audio_set_mute, METH_VARARGS,
744       "audio_set_mute(state=int)         Set the mute state"},
745     { "audio_get_volume", vlcInstance_audio_get_volume, METH_VARARGS,
746       "audio_get_volume() -> int   Get the audio volume"},
747     { "audio_set_volume", vlcInstance_audio_set_volume, METH_VARARGS,
748       "audio_set_volume(volume=int)       Set the audio volume"},
749     { "audio_get_channel", vlcInstance_audio_get_channel, METH_VARARGS,
750       "audio_get_channel() -> int  Get current audio channel" },
751     { "audio_set_channel", vlcInstance_audio_set_channel, METH_VARARGS,
752       "audio_set_channel(int)      Set current audio channel" },
753     { "vlm_add_broadcast", vlcInstance_vlm_add_broadcast, METH_VARARGS | METH_KEYWORDS,
754       "vlm_add_broadcast(name=str, input=str, output=str, options=list, enable=int, loop=int)   Add a new broadcast" },
755     { "vlm_del_media", vlcInstance_vlm_del_media, METH_VARARGS,
756       "vlm_del_media(name=str)    Delete a media" },
757     { "vlm_set_enabled", vlcInstance_vlm_set_enabled, METH_VARARGS,
758       "vlm_set_enabled(name=str, enabled=int)    Enable/disable a media" },
759     { "vlm_set_output", vlcInstance_vlm_set_output, METH_VARARGS,
760       "vlm_set_output(name=str, output=str)      Set the output" },
761     { "vlm_set_input", vlcInstance_vlm_set_input, METH_VARARGS,
762       "vlm_set_input(name=str, output=str)       Set the input" },
763     { "vlm_set_loop", vlcInstance_vlm_set_loop, METH_VARARGS,
764       "vlm_set_loop(name=str, loop=int)          Change the looping value" },
765     { "vlm_change_media", vlcInstance_vlm_change_media, METH_VARARGS | METH_KEYWORDS,
766       "vlm_change_media(name=str, input=str, output=str, options=list, enable=int, loop=int)   Change the broadcast parameters" },
767     { "vlm_play_media", vlcInstance_vlm_play_media, METH_VARARGS,
768       "vlm_play_media(name=str)       Plays the named broadcast." },
769     { "vlm_stop_media", vlcInstance_vlm_stop_media, METH_VARARGS,
770       "vlm_stop_media(name=str)       Stops the named broadcast." },
771     { "vlm_pause_media", vlcInstance_vlm_pause_media, METH_VARARGS,
772       "vlm_pause_media(name=str)      Pauses the named broadcast." },
773     { "vlm_seek_media", vlcInstance_vlm_seek_media, METH_VARARGS,
774       "vlm_seek_media(name=str, percentage=float)  Seeks in the named broadcast." },
775     { "vlm_show_media", vlcInstance_vlm_show_media, METH_VARARGS,
776       "vlm_show_media(name=str)       Return information of the named broadcast." },
777
778     { NULL, NULL, 0, NULL },
779 };
780
781 static PyTypeObject vlcInstance_Type =
782 {
783     PyObject_HEAD_INIT( NULL )
784     0,                          /*ob_size*/
785     "vlc.Instance",             /*tp_name*/
786     sizeof( vlcInstance_Type ), /*tp_basicsize*/
787     0,                          /*tp_itemsize*/
788     ( destructor )vlcInstance_dealloc,      /*tp_dealloc*/
789     0,                         /*tp_print*/
790     0,                         /*tp_getattr*/
791     0,                         /*tp_setattr*/
792     0,                         /*tp_compare*/
793     0,                         /*tp_repr*/
794     0,                         /*tp_as_number*/
795     0,                         /*tp_as_sequence*/
796     0,                         /*tp_as_mapping*/
797     0,                         /*tp_hash */
798     0,                         /*tp_call*/
799     0,                         /*tp_str*/
800     0,                         /*tp_getattro*/
801     0,                         /*tp_setattro*/
802     0,                         /*tp_as_buffer*/
803     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
804     "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 */
805     0,                     /* tp_traverse */
806     0,                     /* tp_clear */
807     0,                     /* tp_richcompare */
808     0,                     /* tp_weaklistoffset */
809     0,                     /* tp_iter */
810     0,                     /* tp_iternext */
811     vlcInstance_methods,             /* tp_methods */
812     0,             /* tp_members */
813     0,                         /* tp_getset */
814     0,                         /* tp_base */
815     0,                         /* tp_dict */
816     0,                         /* tp_descr_get */
817     0,                         /* tp_descr_set */
818     0,                         /* tp_dictoffset */
819     0,                         /* tp_init */
820     0,                         /* tp_alloc */
821     vlcInstance_new,          /* tp_new */
822 };