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