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