git.sesse.net Git - vlc/blob - 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 };