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