bindings/python/vlc_instance.c

   1 /*****************************************************************************
   2  * vlc_instance.c: vlc.Instance binding
   3  *****************************************************************************
   4  * Copyright (C) 2006,2007,2008,2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Olivier Aubert <olivier.aubert at liris.cnrs.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23 #include "vlcglue.h"
  24
  25 /* Helper functions */
  26 static Py_ssize_t
  27 pyoptions_to_args(PyObject *py_options, char*** pppsz_args)
  28 {
  29     Py_ssize_t i_size;
  30     Py_ssize_t  i_index;
  31
  32     Py_INCREF( py_options );
  33     if( ! PySequence_Check( py_options ) )
  34     {
  35         PyErr_SetString( PyExc_TypeError, "Parameter must be a sequence." );
  36         return -1;
  37     }
  38     i_size = PySequence_Size( py_options );
  39
  40     char **ppsz_args = *pppsz_args = malloc( ( i_size + 1 ) * sizeof( char * ) );
  41
  42     if( ! ppsz_args )
  43     {
  44         PyErr_SetString( PyExc_MemoryError, "Out of memory" );
  45         return -1;
  46     }
  47
  48     for ( i_index = 0; i_index < i_size; i_index++ )
  49     {
  50         ppsz_args[i_index] =
  51             strdup( PyString_AsString( PyObject_Str(
  52                                            PySequence_GetItem( py_options,
  53                                                                i_index ) ) ) );
  54     }
  55     ppsz_args[i_size] = NULL;
  56     Py_DECREF( py_options );
  57     return i_size;
  58 }
  59
  60 static void
  61 free_args(int i_size, char** ppsz_args)
  62 {
  63     int i_index;
  64
  65     for ( i_index = 0; i_index < i_size; i_index++ )
  66         free( ppsz_args[i_index] );
  67     free( ppsz_args );
  68 }
  69
  70 /*****************************************************************************
  71  * Instance object implementation
  72  *****************************************************************************/
  73
  74 static PyObject *
  75 vlcInstance_new( PyTypeObject *type, PyObject *args, PyObject *kwds )
  76 {
  77     vlcInstance *self;
  78     libvlc_exception_t ex;
  79     PyObject* py_list = NULL;
  80     char** ppsz_args = NULL;
  81     int i_size = 0;
  82
  83     fprintf(stderr, "Instantiating\n");
  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(self) = 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(self) );
 114     PyObject_DEL( self );
 115 }
 116
 117 static PyObject *
 118 vlcInstance_new_media_player( PyObject *self, PyObject *args )
 119 {
 120     libvlc_exception_t ex;
 121     libvlc_media_player_t *p_mp;
 122     vlcMediaPlayer *p_ret;
 123
 124     LIBVLC_TRY;
 125     p_mp = libvlc_media_player_new( LIBVLC_INSTANCE(self), &ex );
 126     LIBVLC_EXCEPT;
 127
 128     p_ret = PyObject_New( vlcMediaPlayer, &vlcMediaPlayer_Type );
 129     p_ret->p_mp = p_mp;
 130     Py_INCREF( p_ret ); /* Ah bon ? */
 131     return ( PyObject * )p_ret;
 132 }
 133
 134 static PyObject *
 135 vlcInstance_audio_toggle_mute( PyObject *self, PyObject *args )
 136 {
 137     libvlc_exception_t ex;
 138     LIBVLC_TRY;
 139     libvlc_audio_toggle_mute( LIBVLC_INSTANCE(self), &ex );
 140     LIBVLC_EXCEPT;
 141     Py_INCREF( Py_None );
 142     return Py_None;
 143 }
 144
 145 static PyObject *
 146 vlcInstance_audio_get_mute( PyObject *self, PyObject *args )
 147 {
 148     libvlc_exception_t ex;
 149     int i_ret;
 150
 151     LIBVLC_TRY;
 152     i_ret = libvlc_audio_get_mute( LIBVLC_INSTANCE(self), &ex );
 153     LIBVLC_EXCEPT;
 154     return Py_BuildValue( "i", i_ret );
 155 }
 156
 157 static PyObject *
 158 vlcInstance_audio_set_mute( PyObject *self, PyObject *args )
 159 {
 160     libvlc_exception_t ex;
 161     int i_mute;
 162
 163     if( !PyArg_ParseTuple( args, "i", &i_mute ) )
 164         return NULL;
 165
 166     LIBVLC_TRY;
 167     libvlc_audio_set_mute( LIBVLC_INSTANCE(self), i_mute, &ex );
 168     LIBVLC_EXCEPT;
 169     Py_INCREF( Py_None );
 170     return Py_None;
 171 }
 172
 173 static PyObject *
 174 vlcInstance_audio_get_volume( PyObject *self, PyObject *args )
 175 {
 176     libvlc_exception_t ex;
 177     int i_ret;
 178
 179     LIBVLC_TRY;
 180     i_ret = libvlc_audio_get_volume( LIBVLC_INSTANCE(self), &ex );
 181     LIBVLC_EXCEPT;
 182     return Py_BuildValue( "i", i_ret );
 183 }
 184
 185 static PyObject *
 186 vlcInstance_audio_set_volume( PyObject *self, PyObject *args )
 187 {
 188     libvlc_exception_t ex;
 189     int i_volume;
 190
 191     if( !PyArg_ParseTuple( args, "i", &i_volume ) )
 192         return NULL;
 193
 194     LIBVLC_TRY;
 195     libvlc_audio_set_volume( LIBVLC_INSTANCE(self), i_volume, &ex );
 196     LIBVLC_EXCEPT;
 197     Py_INCREF( Py_None );
 198     return Py_None;
 199 }
 200
 201 static PyObject *
 202 vlcInstance_audio_get_channel( PyObject *self, PyObject *args )
 203 {
 204     libvlc_exception_t ex;
 205     int i_ret;
 206
 207     LIBVLC_TRY;
 208     i_ret = libvlc_audio_get_channel( LIBVLC_INSTANCE(self), &ex );
 209     LIBVLC_EXCEPT;
 210     return Py_BuildValue( "i", i_ret );
 211 }
 212
 213 static PyObject *
 214 vlcInstance_audio_set_channel( PyObject *self, PyObject *args )
 215 {
 216     libvlc_exception_t ex;
 217     int i_channel;
 218
 219     if( !PyArg_ParseTuple( args, "i", &i_channel ) )
 220         return NULL;
 221
 222     LIBVLC_TRY;
 223     libvlc_audio_set_channel( LIBVLC_INSTANCE(self), i_channel, &ex );
 224     LIBVLC_EXCEPT;
 225     Py_INCREF( Py_None );
 226     return Py_None;
 227 }
 228
 229 /* vlm_add_broadcast : name, input MRL, output MRL
 230    Keywords: options, enable, loop */
 231 static PyObject *
 232 vlcInstance_vlm_add_broadcast( PyObject *self, PyObject *args, PyObject *kwds )
 233 {
 234     libvlc_exception_t ex;
 235     static char *kwlist[] = { "name", "input", "output",
 236                               "options", "enable", "loop", NULL};
 237     char* psz_name = NULL;
 238     char* psz_input = NULL;
 239     char* psz_output = NULL;
 240     PyObject* py_options = NULL;
 241     int i_enable = 1;
 242     int i_loop = 0;
 243     int i_size = 0;
 244     char** ppsz_args = NULL;
 245
 246     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist,
 247                                       &psz_name,
 248                       &psz_input, &psz_output,
 249                       &py_options, &i_enable, &i_loop ) )
 250         return NULL;
 251
 252     if( py_options )
 253     {
 254         i_size = pyoptions_to_args( py_options, &ppsz_args );
 255     }
 256
 257     LIBVLC_TRY;
 258     libvlc_vlm_add_broadcast( LIBVLC_INSTANCE(self),
 259                               psz_name, psz_input, psz_output,
 260                               i_size, ppsz_args, i_enable, i_loop, &ex);
 261     free_args( i_size, ppsz_args );
 262     LIBVLC_EXCEPT;
 263     Py_INCREF( Py_None );
 264     return Py_None;
 265 }
 266
 267 static PyObject *
 268 vlcInstance_vlm_del_media( PyObject *self, PyObject *args )
 269 {
 270     libvlc_exception_t ex;
 271     char* psz_name;
 272
 273     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 274         return NULL;
 275
 276     LIBVLC_TRY;
 277     libvlc_vlm_del_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 278     LIBVLC_EXCEPT;
 279     Py_INCREF( Py_None );
 280     return Py_None;
 281 }
 282
 283 static PyObject *
 284 vlcInstance_vlm_set_enabled( PyObject *self, PyObject *args )
 285 {
 286     libvlc_exception_t ex;
 287     char* psz_name;
 288     int i_enabled;
 289
 290     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_enabled ) )
 291         return NULL;
 292
 293     LIBVLC_TRY;
 294     libvlc_vlm_set_enabled( LIBVLC_INSTANCE(self), psz_name, i_enabled, &ex);
 295     LIBVLC_EXCEPT;
 296     Py_INCREF( Py_None );
 297     return Py_None;
 298 }
 299
 300 static PyObject *
 301 vlcInstance_vlm_set_output( PyObject *self, PyObject *args )
 302 {
 303     libvlc_exception_t ex;
 304     char* psz_name;
 305     char* psz_output;
 306
 307     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_output ) )
 308         return NULL;
 309
 310     LIBVLC_TRY;
 311     libvlc_vlm_set_output( LIBVLC_INSTANCE(self), psz_name, psz_output, &ex);
 312     LIBVLC_EXCEPT;
 313     Py_INCREF( Py_None );
 314     return Py_None;
 315 }
 316
 317 static PyObject *
 318 vlcInstance_vlm_set_input( PyObject *self, PyObject *args )
 319 {
 320     libvlc_exception_t ex;
 321     char* psz_name;
 322     char* psz_input;
 323
 324     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
 325         return NULL;
 326
 327     LIBVLC_TRY;
 328     libvlc_vlm_set_input( LIBVLC_INSTANCE(self), psz_name, psz_input, &ex);
 329     LIBVLC_EXCEPT;
 330     Py_INCREF( Py_None );
 331     return Py_None;
 332 }
 333
 334 static PyObject *
 335 vlcInstance_vlm_add_input( PyObject *self, PyObject *args )
 336 {
 337     libvlc_exception_t ex;
 338     char* psz_name;
 339     char* psz_input;
 340
 341     if( !PyArg_ParseTuple( args, "ss", &psz_name, &psz_input ) )
 342         return NULL;
 343
 344     LIBVLC_TRY;
 345     libvlc_vlm_add_input( LIBVLC_INSTANCE(self), psz_name, psz_input, &ex);
 346     LIBVLC_EXCEPT;
 347     Py_INCREF( Py_None );
 348     return Py_None;
 349 }
 350
 351 static PyObject *
 352 vlcInstance_vlm_set_loop( PyObject *self, PyObject *args )
 353 {
 354     libvlc_exception_t ex;
 355     char* psz_name;
 356     int i_loop;
 357
 358     if( !PyArg_ParseTuple( args, "si", &psz_name, &i_loop ) )
 359         return NULL;
 360
 361     LIBVLC_TRY;
 362     libvlc_vlm_set_loop( LIBVLC_INSTANCE(self), psz_name, i_loop, &ex);
 363     LIBVLC_EXCEPT;
 364     Py_INCREF( Py_None );
 365     return Py_None;
 366 }
 367
 368 static PyObject *
 369 vlcInstance_vlm_change_media( PyObject *self, PyObject *args, PyObject *kwds )
 370 {
 371     libvlc_exception_t ex;
 372     static char *kwlist[] = { "name", "input", "output",
 373                               "options", "enable", "loop", NULL};
 374     char* psz_name = NULL;
 375     char* psz_input = NULL;
 376     char* psz_output = NULL;
 377     PyObject* py_options = NULL;
 378     int i_enable = 1;
 379     int i_loop = 0;
 380     int i_size = 0;
 381     char** ppsz_args = NULL;
 382
 383     if( !PyArg_ParseTupleAndKeywords( args, kwds, "sss|Oii", kwlist,
 384                                       &psz_name,
 385                       &psz_input, &psz_output,
 386                       &py_options, &i_enable, &i_loop ) )
 387         return NULL;
 388
 389     if( py_options )
 390     {
 391         i_size = pyoptions_to_args( py_options, &ppsz_args );
 392     }
 393
 394     LIBVLC_TRY;
 395     libvlc_vlm_change_media( LIBVLC_INSTANCE(self),
 396                               psz_name, psz_input, psz_output,
 397                               i_size, ppsz_args, i_enable, i_loop, &ex);
 398     free_args( i_size, ppsz_args );
 399     LIBVLC_EXCEPT;
 400     Py_INCREF( Py_None );
 401     return Py_None;
 402 }
 403
 404 static PyObject *
 405 vlcInstance_vlm_play_media( PyObject *self, PyObject *args )
 406 {
 407     libvlc_exception_t ex;
 408     char* psz_name;
 409
 410     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 411         return NULL;
 412
 413     LIBVLC_TRY;
 414     libvlc_vlm_play_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 415     LIBVLC_EXCEPT;
 416     Py_INCREF( Py_None );
 417     return Py_None;
 418 }
 419
 420 static PyObject *
 421 vlcInstance_vlm_stop_media( PyObject *self, PyObject *args )
 422 {
 423     libvlc_exception_t ex;
 424     char* psz_name;
 425
 426     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 427         return NULL;
 428
 429     LIBVLC_TRY;
 430     libvlc_vlm_stop_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 431     LIBVLC_EXCEPT;
 432     Py_INCREF( Py_None );
 433     return Py_None;
 434 }
 435
 436 static PyObject *
 437 vlcInstance_vlm_pause_media( PyObject *self, PyObject *args )
 438 {
 439     libvlc_exception_t ex;
 440     char* psz_name;
 441
 442     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 443         return NULL;
 444
 445     LIBVLC_TRY;
 446     libvlc_vlm_pause_media( LIBVLC_INSTANCE(self), psz_name, &ex);
 447     LIBVLC_EXCEPT;
 448     Py_INCREF( Py_None );
 449     return Py_None;
 450 }
 451
 452 static PyObject *
 453 vlcInstance_vlm_seek_media( PyObject *self, PyObject *args )
 454 {
 455     libvlc_exception_t ex;
 456     char* psz_name;
 457     float f_percentage;
 458
 459     if( !PyArg_ParseTuple( args, "sf", &psz_name, &f_percentage ) )
 460         return NULL;
 461
 462     LIBVLC_TRY;
 463     libvlc_vlm_seek_media( LIBVLC_INSTANCE(self), psz_name, f_percentage, &ex);
 464     LIBVLC_EXCEPT;
 465     Py_INCREF( Py_None );
 466     return Py_None;
 467 }
 468
 469 static PyObject *
 470 vlcInstance_vlm_show_media( PyObject *self, PyObject *args )
 471 {
 472     libvlc_exception_t ex;
 473     char* psz_name;
 474     char* psz_ret;
 475     PyObject* o_ret;
 476
 477     if( !PyArg_ParseTuple( args, "s", &psz_name ) )
 478         return NULL;
 479     LIBVLC_TRY;
 480     psz_ret = libvlc_vlm_show_media( LIBVLC_INSTANCE(self), psz_name, &ex );
 481     LIBVLC_EXCEPT;
 482     o_ret = Py_BuildValue( "s", psz_ret );
 483     free( psz_ret );
 484     return o_ret;
 485 }
 486
 487 static PyObject *
 488 vlcInstance_media_new( PyObject *self, PyObject *args )
 489 {
 490     libvlc_exception_t ex;
 491     libvlc_media_t *p_media;
 492     char* psz_mrl = NULL;
 493     vlcMedia *p_ret;
 494
 495     if( !PyArg_ParseTuple( args, "s", &psz_mrl ) )
 496         return NULL;
 497
 498     LIBVLC_TRY;
 499     p_media = libvlc_media_new( LIBVLC_INSTANCE(self), psz_mrl, &ex );
 500     LIBVLC_EXCEPT;
 501
 502     p_ret = PyObject_New( vlcMedia, &vlcMedia_Type );
 503     p_ret->p_media = p_media;
 504     Py_INCREF( p_ret ); /* Ah bon ? */
 505     return ( PyObject * )p_ret;
 506 }
 507
 508 /* Method table */
 509 static PyMethodDef vlcInstance_methods[] =
 510 {
 511     { "get_vlc_id", vlcInstance_get_vlc_id, METH_NOARGS,
 512       "get_vlc_id( ) -> int        Get the instance id."},
 513     { "audio_toggle_mute", vlcInstance_audio_toggle_mute, METH_NOARGS,
 514       "audio_toggle_mute()         Toggle the mute state"},
 515     { "audio_get_mute", vlcInstance_audio_get_mute, METH_NOARGS,
 516       "audio_get_mute() -> int     Get the mute state"},
 517     { "audio_set_mute", vlcInstance_audio_set_mute, METH_VARARGS,
 518       "audio_set_mute(state=int)         Set the mute state"},
 519     { "audio_get_volume", vlcInstance_audio_get_volume, METH_NOARGS,
 520       "audio_get_volume() -> int   Get the audio volume"},
 521     { "audio_set_volume", vlcInstance_audio_set_volume, METH_VARARGS,
 522       "audio_set_volume(volume=int)       Set the audio volume"},
 523     { "audio_get_channel", vlcInstance_audio_get_channel, METH_NOARGS,
 524       "audio_get_channel() -> int  Get current audio channel" },
 525     { "audio_set_channel", vlcInstance_audio_set_channel, METH_VARARGS,
 526       "audio_set_channel(int)      Set current audio channel" },
 527
 528     { "media_new", vlcInstance_media_new, METH_VARARGS,
 529       "media_new(str) -> object   Create a media object with the given mrl."},
 530
 531     { "mediaplayer_new", vlcInstance_new_media_player, METH_NOARGS,
 532       "mediaplayer_new() -> object   Create a media player."},
 533
 534     { "vlm_add_broadcast", vlcInstance_vlm_add_broadcast, METH_VARARGS | METH_KEYWORDS,
 535       "vlm_add_broadcast(name=str, input=str, output=str, options=list, enable=int, loop=int)   Add a new broadcast" },
 536     { "vlm_del_media", vlcInstance_vlm_del_media, METH_VARARGS,
 537       "vlm_del_media(name=str)    Delete a media" },
 538     { "vlm_set_enabled", vlcInstance_vlm_set_enabled, METH_VARARGS,
 539       "vlm_set_enabled(name=str, enabled=int)    Enable/disable a media" },
 540     { "vlm_set_output", vlcInstance_vlm_set_output, METH_VARARGS,
 541       "vlm_set_output(name=str, output=str)      Set the output" },
 542     { "vlm_set_input", vlcInstance_vlm_set_input, METH_VARARGS,
 543       "vlm_set_input(name=str, output=str)       Set the input" },
 544     { "vlm_add_input", vlcInstance_vlm_add_input, METH_VARARGS,
 545       "vlm_add_input(name=str, output=str)       Add a media's input MRL" },
 546     { "vlm_set_loop", vlcInstance_vlm_set_loop, METH_VARARGS,
 547       "vlm_set_loop(name=str, loop=int)          Change the looping value" },
 548     { "vlm_change_media", vlcInstance_vlm_change_media, METH_VARARGS | METH_KEYWORDS,
 549       "vlm_change_media(name=str, input=str, output=str, options=list, enable=int, loop=int)   Change the broadcast parameters" },
 550     { "vlm_play_media", vlcInstance_vlm_play_media, METH_VARARGS,
 551       "vlm_play_media(name=str)       Plays the named broadcast." },
 552     { "vlm_stop_media", vlcInstance_vlm_stop_media, METH_VARARGS,
 553       "vlm_stop_media(name=str)       Stops the named broadcast." },
 554     { "vlm_pause_media", vlcInstance_vlm_pause_media, METH_VARARGS,
 555       "vlm_pause_media(name=str)      Pauses the named broadcast." },
 556     { "vlm_seek_media", vlcInstance_vlm_seek_media, METH_VARARGS,
 557       "vlm_seek_media(name=str, percentage=float)  Seeks in the named broadcast." },
 558     { "vlm_show_media", vlcInstance_vlm_show_media, METH_VARARGS,
 559       "vlm_show_media(name=str)       Return information of the named broadcast." },
 560
 561     { NULL, NULL, 0, NULL },
 562 };
 563
 564 static PyTypeObject vlcInstance_Type =
 565 {
 566     PyObject_HEAD_INIT( NULL )
 567     0,                          /*ob_size*/
 568     "vlc.Instance",             /*tp_name*/
 569     sizeof( vlcInstance_Type ), /*tp_basicsize*/
 570     0,                          /*tp_itemsize*/
 571     ( destructor )vlcInstance_dealloc,      /*tp_dealloc*/
 572     0,                         /*tp_print*/
 573     0,                         /*tp_getattr*/
 574     0,                         /*tp_setattr*/
 575     0,                         /*tp_compare*/
 576     0,                         /*tp_repr*/
 577     0,                         /*tp_as_number*/
 578     0,                         /*tp_as_sequence*/
 579     0,                         /*tp_as_mapping*/
 580     0,                         /*tp_hash */
 581     0,                         /*tp_call*/
 582     0,                         /*tp_str*/
 583     0,                         /*tp_getattro*/
 584     0,                         /*tp_setattro*/
 585     0,                         /*tp_as_buffer*/
 586     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 587     "VLC Instance(args)",  /* tp_doc */
 588     0,                     /* tp_traverse */
 589     0,                     /* tp_clear */
 590     0,                     /* tp_richcompare */
 591     0,                     /* tp_weaklistoffset */
 592     0,                     /* tp_iter */
 593     0,                     /* tp_iternext */
 594     vlcInstance_methods,             /* tp_methods */
 595     0,             /* tp_members */
 596     0,                         /* tp_getset */
 597     0,                         /* tp_base */
 598     0,                         /* tp_dict */
 599     0,                         /* tp_descr_get */
 600     0,                         /* tp_descr_set */
 601     0,                         /* tp_dictoffset */
 602     0,                         /* tp_init */
 603     0,                         /* tp_alloc */
 604     vlcInstance_new,          /* tp_new */
 605 };