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