src/libvlc.c

   1 /*****************************************************************************
   2  * libvlc.c: Implementation of the old libvlc API
   3  *****************************************************************************
   4  * Copyright (C) 1998-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Vincent Seguin <seguin@via.ecp.fr>
   8  *          Samuel Hocevar <sam@zoy.org>
   9  *          Gildas Bazin <gbazin@videolan.org>
  10  *          Derk-Jan Hartman <hartman at videolan dot org>
  11  *          Rémi Denis-Courmont <rem # videolan : org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 /*****************************************************************************
  29  * Pretend we are a builtin module
  30  *****************************************************************************/
  31 #define MODULE_NAME main
  32 #define MODULE_PATH main
  33 #define __BUILTIN__
  34
  35 /*****************************************************************************
  36  * Preamble
  37  *****************************************************************************/
  38 #ifdef HAVE_CONFIG_H
  39 # include "config.h"
  40 #endif
  41
  42 #include <vlc/vlc.h>
  43
  44 #include "control/libvlc_internal.h"
  45 #include "libvlc.h"
  46
  47 #include <vlc_playlist.h>
  48
  49 #include <vlc_aout.h>
  50 #include <vlc_vout.h>
  51
  52 /*****************************************************************************
  53  * VLC_Version: return the libvlc version.
  54  *****************************************************************************
  55  * This function returns full version string (numeric version and codename).
  56  *****************************************************************************/
  57 char const * VLC_Version( void )
  58 {
  59     return VERSION_MESSAGE;
  60 }
  61
  62 /*****************************************************************************
  63  * VLC_CompileBy, VLC_CompileHost, VLC_CompileDomain,
  64  * VLC_Compiler, VLC_Changeset
  65  *****************************************************************************/
  66 #define DECLARE_VLC_VERSION( func, var )                                    \
  67 char const * VLC_##func ( void )                                            \
  68 {                                                                           \
  69     return VLC_##var ;                                                      \
  70 }
  71
  72 DECLARE_VLC_VERSION( CompileBy, COMPILE_BY );
  73 DECLARE_VLC_VERSION( CompileHost, COMPILE_HOST );
  74 DECLARE_VLC_VERSION( CompileDomain, COMPILE_DOMAIN );
  75 DECLARE_VLC_VERSION( Compiler, COMPILER );
  76
  77 extern const char psz_vlc_changeset[];
  78 const char* VLC_Changeset( void )
  79 {
  80     return psz_vlc_changeset;
  81 }
  82
  83 /*****************************************************************************
  84  * VLC_Error: strerror() equivalent
  85  *****************************************************************************
  86  * This function returns full version string (numeric version and codename).
  87  *****************************************************************************/
  88 char const * VLC_Error( int i_err )
  89 {
  90     return vlc_error( i_err );
  91 }
  92
  93 /*****************************************************************************
  94  * VLC_Create: allocate a libvlc instance and intialize global libvlc stuff if needed
  95  *****************************************************************************
  96  * This function allocates a libvlc instance and returns a negative value
  97  * in case of failure. Also, the thread system is initialized.
  98  *****************************************************************************/
  99 int VLC_Create( void )
 100 {
 101     libvlc_int_t *p_object = libvlc_InternalCreate();
 102     if( p_object ) return p_object->i_object_id;
 103     return VLC_ENOOBJ;
 104 }
 105
 106 #define LIBVLC_FUNC \
 107     libvlc_int_t * p_libvlc = vlc_current_object( i_object ); \
 108     if( !p_libvlc ) return VLC_ENOOBJ;
 109 #define LIBVLC_FUNC_END \
 110     if( i_object ) vlc_object_release( p_libvlc );
 111
 112
 113 /*****************************************************************************
 114  * VLC_Init: initialize a libvlc instance
 115  *****************************************************************************
 116  * This function initializes a previously allocated libvlc instance:
 117  *  - CPU detection
 118  *  - gettext initialization
 119  *  - message queue, module bank and playlist initialization
 120  *  - configuration and commandline parsing
 121  *****************************************************************************/
 122 int VLC_Init( int i_object, int i_argc, const char *ppsz_argv[] )
 123 {
 124     int i_ret;
 125     LIBVLC_FUNC;
 126     i_ret = libvlc_InternalInit( p_libvlc, i_argc, ppsz_argv );
 127     LIBVLC_FUNC_END;
 128     return i_ret;
 129 }
 130
 131 /*****************************************************************************
 132  * VLC_AddIntf: add an interface
 133  *****************************************************************************
 134  * This function opens an interface plugin and runs it. If b_block is set
 135  * to 0, VLC_AddIntf will return immediately and let the interface run in a
 136  * separate thread. If b_block is set to 1, VLC_AddIntf will continue until
 137  * user requests to quit. If b_play is set to 1, VLC_AddIntf will start playing
 138  * the playlist when it is completely initialised.
 139  *****************************************************************************/
 140 int VLC_AddIntf( int i_object, char const *psz_module,
 141                  vlc_bool_t b_block, vlc_bool_t b_play )
 142 {
 143     int i_ret;
 144     LIBVLC_FUNC;
 145     i_ret = libvlc_InternalAddIntf( p_libvlc, psz_module, b_block, b_play,
 146                                     0, NULL );
 147     LIBVLC_FUNC_END;
 148     return i_ret;
 149 }
 150
 151
 152 /*****************************************************************************
 153  * VLC_Die: ask vlc to die.
 154  *****************************************************************************
 155  * This function sets p_libvlc->b_die to VLC_TRUE, but does not do any other
 156  * task. It is your duty to call VLC_CleanUp and VLC_Destroy afterwards.
 157  *****************************************************************************/
 158 int VLC_Die( int i_object )
 159 {
 160     LIBVLC_FUNC;
 161     vlc_object_kill( p_libvlc );
 162     LIBVLC_FUNC_END;
 163     return VLC_SUCCESS;
 164 }
 165
 166 /*****************************************************************************
 167  * VLC_CleanUp: CleanUp all the intf, playlist, vout, aout
 168  *****************************************************************************/
 169 int VLC_CleanUp( int i_object )
 170 {
 171     int i_ret;
 172     LIBVLC_FUNC;
 173     i_ret = libvlc_InternalCleanup( p_libvlc );
 174     LIBVLC_FUNC_END;
 175     return i_ret;
 176 }
 177
 178 /*****************************************************************************
 179  * VLC_Destroy: Destroy everything.
 180  *****************************************************************************
 181  * This function requests the running threads to finish, waits for their
 182  * termination, and destroys their structure.
 183  *****************************************************************************/
 184 int VLC_Destroy( int i_object )
 185 {
 186     LIBVLC_FUNC;
 187     return libvlc_InternalDestroy( p_libvlc, i_object ? VLC_TRUE : VLC_FALSE );
 188 }
 189
 190 /*****************************************************************************
 191  * VLC_VariableSet: set a vlc variable
 192  *****************************************************************************/
 193 int VLC_VariableSet( int i_object, char const *psz_var, vlc_value_t value )
 194 {
 195     int i_ret;
 196     LIBVLC_FUNC;
 197
 198     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
 199      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
 200     if( !strncmp( psz_var, "conf::", 6 ) )
 201     {
 202         module_config_t *p_item;
 203         char const *psz_newvar = psz_var + 6;
 204
 205         p_item = config_FindConfig( VLC_OBJECT(p_libvlc), psz_newvar );
 206
 207         if( p_item )
 208         {
 209             switch( p_item->i_type )
 210             {
 211                 case CONFIG_ITEM_BOOL:
 212                     config_PutInt( p_libvlc, psz_newvar, value.b_bool );
 213                     break;
 214                 case CONFIG_ITEM_INTEGER:
 215                     config_PutInt( p_libvlc, psz_newvar, value.i_int );
 216                     break;
 217                 case CONFIG_ITEM_FLOAT:
 218                     config_PutFloat( p_libvlc, psz_newvar, value.f_float );
 219                     break;
 220                 default:
 221                     config_PutPsz( p_libvlc, psz_newvar, value.psz_string );
 222                     break;
 223             }
 224             if( i_object ) vlc_object_release( p_libvlc );
 225             return VLC_SUCCESS;
 226         }
 227     }
 228
 229     i_ret = var_Set( p_libvlc, psz_var, value );
 230
 231     LIBVLC_FUNC_END;
 232     return i_ret;
 233 }
 234
 235 /*****************************************************************************
 236  * VLC_VariableGet: get a vlc variable
 237  *****************************************************************************/
 238 int VLC_VariableGet( int i_object, char const *psz_var, vlc_value_t *p_value )
 239 {
 240     int i_ret;
 241     LIBVLC_FUNC;
 242     i_ret = var_Get( p_libvlc , psz_var, p_value );
 243     LIBVLC_FUNC_END;
 244     return i_ret;
 245 }
 246
 247 /*****************************************************************************
 248  * VLC_VariableType: get a vlc variable type
 249  *****************************************************************************/
 250 int VLC_VariableType( int i_object, char const *psz_var, int *pi_type )
 251 {
 252     int i_type;
 253     LIBVLC_FUNC;
 254     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
 255      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
 256     if( !strncmp( psz_var, "conf::", 6 ) )
 257     {
 258         module_config_t *p_item;
 259         char const *psz_newvar = psz_var + 6;
 260
 261         p_item = config_FindConfig( VLC_OBJECT(p_libvlc), psz_newvar );
 262
 263         if( p_item )
 264         {
 265             switch( p_item->i_type )
 266             {
 267                 case CONFIG_ITEM_BOOL:
 268                     i_type = VLC_VAR_BOOL;
 269                     break;
 270                 case CONFIG_ITEM_INTEGER:
 271                     i_type = VLC_VAR_INTEGER;
 272                     break;
 273                 case CONFIG_ITEM_FLOAT:
 274                     i_type = VLC_VAR_FLOAT;
 275                     break;
 276                 default:
 277                     i_type = VLC_VAR_STRING;
 278                     break;
 279             }
 280         }
 281         else
 282             i_type = 0;
 283     }
 284     else
 285         i_type = VLC_VAR_TYPE & var_Type( p_libvlc , psz_var );
 286
 287     LIBVLC_FUNC_END;
 288
 289     if( i_type > 0 )
 290     {
 291         *pi_type = i_type;
 292         return VLC_SUCCESS;
 293     }
 294     return VLC_ENOVAR;
 295 }
 296
 297 #define LIBVLC_PLAYLIST_FUNC \
 298     libvlc_int_t *p_libvlc = vlc_current_object( i_object );\
 299     if( !p_libvlc || !p_libvlc->p_playlist ) return VLC_ENOOBJ; \
 300     vlc_object_yield( p_libvlc->p_playlist );
 301
 302 #define LIBVLC_PLAYLIST_FUNC_END \
 303     vlc_object_release( p_libvlc->p_playlist ); \
 304     if( i_object ) vlc_object_release( p_libvlc );
 305
 306 /*****************************************************************************
 307  * VLC_AddTarget: adds a target for playing.
 308  *****************************************************************************
 309  * This function adds psz_target to the playlist
 310  *****************************************************************************/
 311
 312 int VLC_AddTarget( int i_object, char const *psz_target,
 313                    char const **ppsz_options, int i_options,
 314                    int i_mode, int i_pos )
 315 {
 316     int i_err;
 317     LIBVLC_PLAYLIST_FUNC;
 318     i_err = playlist_AddExt( p_libvlc->p_playlist, psz_target,
 319                              NULL,  i_mode, i_pos, -1,
 320                              ppsz_options, i_options, VLC_TRUE, VLC_FALSE );
 321     LIBVLC_PLAYLIST_FUNC_END;
 322     return i_err;
 323 }
 324
 325 /*****************************************************************************
 326  * VLC_Play: play the playlist
 327  *****************************************************************************/
 328 int VLC_Play( int i_object )
 329 {
 330     LIBVLC_PLAYLIST_FUNC;
 331     playlist_Play( p_libvlc->p_playlist );
 332     LIBVLC_PLAYLIST_FUNC_END;
 333     return VLC_SUCCESS;
 334 }
 335
 336 /*****************************************************************************
 337  * VLC_Pause: toggle pause
 338  *****************************************************************************/
 339 int VLC_Pause( int i_object )
 340 {
 341     LIBVLC_PLAYLIST_FUNC;
 342     playlist_Pause( p_libvlc->p_playlist );
 343     LIBVLC_PLAYLIST_FUNC_END;
 344     return VLC_SUCCESS;
 345 }
 346
 347 /*****************************************************************************
 348  * VLC_Stop: stop playback
 349  *****************************************************************************/
 350 int VLC_Stop( int i_object )
 351 {
 352     LIBVLC_PLAYLIST_FUNC;
 353     playlist_Stop( p_libvlc->p_playlist );
 354     LIBVLC_PLAYLIST_FUNC_END;
 355     return VLC_SUCCESS;
 356 }
 357
 358 /*****************************************************************************
 359  * VLC_IsPlaying: Query for Playlist Status
 360  *****************************************************************************/
 361 vlc_bool_t VLC_IsPlaying( int i_object )
 362 {
 363     vlc_bool_t   b_playing;
 364
 365     LIBVLC_PLAYLIST_FUNC;
 366     if( p_libvlc->p_playlist->p_input )
 367     {
 368         vlc_value_t  val;
 369         var_Get( p_libvlc->p_playlist->p_input, "state", &val );
 370         b_playing = ( val.i_int == PLAYING_S );
 371     }
 372     else
 373     {
 374         b_playing = playlist_IsPlaying( p_libvlc->p_playlist );
 375     }
 376     LIBVLC_PLAYLIST_FUNC_END;
 377     return b_playing;
 378 }
 379
 380 /**
 381  * Get the current position in a input
 382  *
 383  * Return the current position as a float
 384  * \note For some inputs, this will be unknown.
 385  *
 386  * \param i_object a vlc object id
 387  * \return a float in the range of 0.0 - 1.0
 388  */
 389 float VLC_PositionGet( int i_object )
 390 {
 391     input_thread_t *p_input;
 392     vlc_value_t val;
 393     LIBVLC_FUNC;
 394
 395     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 396
 397     if( !p_input )
 398     {
 399         if( i_object ) vlc_object_release( p_libvlc );
 400         return VLC_ENOOBJ;
 401     }
 402
 403     var_Get( p_input, "position", &val );
 404     vlc_object_release( p_input );
 405
 406     LIBVLC_FUNC_END;
 407     return val.f_float;
 408 }
 409
 410 /**
 411  * Set the current position in a input
 412  *
 413  * Set the current position in a input and then return
 414  * the current position as a float.
 415  * \note For some inputs, this will be unknown.
 416  *
 417  * \param i_object a vlc object id
 418  * \param i_position a float in the range of 0.0 - 1.0
 419  * \return a float in the range of 0.0 - 1.0
 420  */
 421 float VLC_PositionSet( int i_object, float i_position )
 422 {
 423     input_thread_t *p_input;
 424     vlc_value_t val;
 425     libvlc_int_t *p_libvlc = vlc_current_object( i_object );
 426
 427     /* Check that the handle is valid */
 428     if( !p_libvlc )
 429     {
 430         return VLC_ENOOBJ;
 431     }
 432
 433     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 434
 435     if( !p_input )
 436     {
 437         if( i_object ) vlc_object_release( p_libvlc );
 438         return VLC_ENOOBJ;
 439     }
 440
 441     val.f_float = i_position;
 442     var_Set( p_input, "position", val );
 443     var_Get( p_input, "position", &val );
 444     vlc_object_release( p_input );
 445
 446     if( i_object ) vlc_object_release( p_libvlc );
 447     return val.f_float;
 448 }
 449
 450 /**
 451  * Get the current position in a input
 452  *
 453  * Return the current position in seconds from the start.
 454  * \note For some inputs, this will be unknown.
 455  *
 456  * \param i_object a vlc object id
 457  * \return the offset from 0:00 in seconds
 458  */
 459 int VLC_TimeGet( int i_object )
 460 {
 461     input_thread_t *p_input;
 462     vlc_value_t val;
 463     libvlc_int_t *p_libvlc = vlc_current_object( i_object );
 464
 465     /* Check that the handle is valid */
 466     if( !p_libvlc )
 467     {
 468         return VLC_ENOOBJ;
 469     }
 470
 471     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 472
 473     if( !p_input )
 474     {
 475         if( i_object ) vlc_object_release( p_libvlc );
 476         return VLC_ENOOBJ;
 477     }
 478
 479     var_Get( p_input, "time", &val );
 480     vlc_object_release( p_input );
 481
 482     if( i_object ) vlc_object_release( p_libvlc );
 483     return val.i_time  / 1000000;
 484 }
 485
 486 /**
 487  * Seek to a position in the current input
 488  *
 489  * Seek i_seconds in the current input. If b_relative is set,
 490  * then the seek will be relative to the current position, otherwise
 491  * it will seek to i_seconds from the beginning of the input.
 492  * \note For some inputs, this will be unknown.
 493  *
 494  * \param i_object a vlc object id
 495  * \param i_seconds seconds from current position or from beginning of input
 496  * \param b_relative seek relative from current position
 497  * \return VLC_SUCCESS on success
 498  */
 499 int VLC_TimeSet( int i_object, int i_seconds, vlc_bool_t b_relative )
 500 {
 501     input_thread_t *p_input;
 502     vlc_value_t val;
 503     libvlc_int_t *p_libvlc = vlc_current_object( i_object );
 504
 505     /* Check that the handle is valid */
 506     if( !p_libvlc )
 507     {
 508         return VLC_ENOOBJ;
 509     }
 510
 511     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 512
 513     if( !p_input )
 514     {
 515         if( i_object ) vlc_object_release( p_libvlc );
 516         return VLC_ENOOBJ;
 517     }
 518
 519     if( b_relative )
 520     {
 521         val.i_time = i_seconds;
 522         val.i_time = val.i_time * 1000000L;
 523         var_Set( p_input, "time-offset", val );
 524     }
 525     else
 526     {
 527         val.i_time = i_seconds;
 528         val.i_time = val.i_time * 1000000L;
 529         var_Set( p_input, "time", val );
 530     }
 531     vlc_object_release( p_input );
 532
 533     if( i_object ) vlc_object_release( p_libvlc );
 534     return VLC_SUCCESS;
 535 }
 536
 537 /**
 538  * Get the total length of a input
 539  *
 540  * Return the total length in seconds from the current input.
 541  * \note For some inputs, this will be unknown.
 542  *
 543  * \param i_object a vlc object id
 544  * \return the length in seconds
 545  */
 546 int VLC_LengthGet( int i_object )
 547 {
 548     input_thread_t *p_input;
 549     vlc_value_t val;
 550     libvlc_int_t *p_libvlc = vlc_current_object( i_object );
 551
 552     /* Check that the handle is valid */
 553     if( !p_libvlc )
 554     {
 555         return VLC_ENOOBJ;
 556     }
 557
 558     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 559
 560     if( !p_input )
 561     {
 562         if( i_object ) vlc_object_release( p_libvlc );
 563         return VLC_ENOOBJ;
 564     }
 565
 566     var_Get( p_input, "length", &val );
 567     vlc_object_release( p_input );
 568
 569     if( i_object ) vlc_object_release( p_libvlc );
 570     return val.i_time  / 1000000L;
 571 }
 572
 573 /**
 574  * Play the input faster than realtime
 575  *
 576  * 2x, 4x, 8x faster than realtime
 577  * \note For some inputs, this will be impossible.
 578  *
 579  * \param i_object a vlc object id
 580  * \return the current speedrate
 581  */
 582 float VLC_SpeedFaster( int i_object )
 583 {
 584     input_thread_t *p_input;
 585     vlc_value_t val;
 586     libvlc_int_t *p_libvlc = vlc_current_object( i_object );
 587
 588     /* Check that the handle is valid */
 589     if( !p_libvlc )
 590     {
 591         return VLC_ENOOBJ;
 592     }
 593
 594     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 595
 596     if( !p_input )
 597     {
 598         if( i_object ) vlc_object_release( p_libvlc );
 599         return VLC_ENOOBJ;
 600     }
 601
 602     val.b_bool = VLC_TRUE;
 603     var_Set( p_input, "rate-faster", val );
 604     var_Get( p_input, "rate", &val );
 605     vlc_object_release( p_input );
 606
 607     if( i_object ) vlc_object_release( p_libvlc );
 608     return val.f_float / INPUT_RATE_DEFAULT;
 609 }
 610
 611 /**
 612  * Play the input slower than realtime
 613  *
 614  * 1/2x, 1/4x, 1/8x slower than realtime
 615  * \note For some inputs, this will be impossible.
 616  *
 617  * \param i_object a vlc object id
 618  * \return the current speedrate
 619  */
 620 float VLC_SpeedSlower( int i_object )
 621 {
 622     input_thread_t *p_input;
 623     vlc_value_t val;
 624     libvlc_int_t *p_libvlc = vlc_current_object( i_object );
 625
 626     /* Check that the handle is valid */
 627     if( !p_libvlc )
 628     {
 629         return VLC_ENOOBJ;
 630     }
 631
 632     p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
 633
 634     if( !p_input )
 635     {
 636         if( i_object ) vlc_object_release( p_libvlc );
 637         return VLC_ENOOBJ;
 638     }
 639
 640     val.b_bool = VLC_TRUE;
 641     var_Set( p_input, "rate-slower", val );
 642     var_Get( p_input, "rate", &val );
 643     vlc_object_release( p_input );
 644
 645     if( i_object ) vlc_object_release( p_libvlc );
 646     return val.f_float / INPUT_RATE_DEFAULT;
 647 }
 648
 649 /**
 650  * Return the current playlist item
 651  *
 652  * Returns the index of the playlistitem that is currently selected for play.
 653  * This is valid even if nothing is currently playing.
 654  *
 655  * \param i_object a vlc object id
 656  * \return the current index
 657  */
 658 int VLC_PlaylistIndex( int i_object )
 659 {
 660     (void)i_object;
 661     printf( "This function is deprecated and should not be used anymore" );
 662     return -1;
 663 }
 664
 665 /**
 666  * Total number of items in the playlist
 667  *
 668  * \param i_object a vlc object id
 669  * \return amount of playlist items
 670  */
 671 int VLC_PlaylistNumberOfItems( int i_object )
 672 {
 673     int i_size;
 674     LIBVLC_PLAYLIST_FUNC;
 675     i_size = p_libvlc->p_playlist->items.i_size;
 676     LIBVLC_PLAYLIST_FUNC_END;
 677     return i_size;
 678 }
 679
 680 /**
 681  * Go to next playlist item
 682  * \param i_object a vlc object id
 683  * \return VLC_SUCCESS on success
 684  */
 685 int VLC_PlaylistNext( int i_object )
 686 {
 687     LIBVLC_PLAYLIST_FUNC;
 688     playlist_Next( p_libvlc->p_playlist );
 689     LIBVLC_PLAYLIST_FUNC_END;
 690     return VLC_SUCCESS;
 691 }
 692
 693 /**
 694  * Go to previous playlist item
 695  * \param i_object a vlc object id
 696  * \return VLC_SUCCESS on success
 697  */
 698 int VLC_PlaylistPrev( int i_object )
 699 {
 700     LIBVLC_PLAYLIST_FUNC;
 701     playlist_Prev( p_libvlc->p_playlist );
 702     LIBVLC_PLAYLIST_FUNC_END;
 703     return VLC_SUCCESS;
 704 }
 705
 706 /**
 707  * Empty the playlist
 708  */
 709 int VLC_PlaylistClear( int i_object )
 710 {
 711     LIBVLC_PLAYLIST_FUNC;
 712     playlist_Clear( p_libvlc->p_playlist, VLC_TRUE );
 713     LIBVLC_PLAYLIST_FUNC_END;
 714     return VLC_SUCCESS;
 715 }
 716
 717 /**
 718  * Change the volume
 719  *
 720  * \param i_object a vlc object id
 721  * \param i_volume something in a range from 0-200
 722  * \return the new volume (range 0-200 %)
 723  */
 724 int VLC_VolumeSet( int i_object, int i_volume )
 725 {
 726     audio_volume_t i_vol = 0;
 727     LIBVLC_FUNC;
 728
 729     if( i_volume >= 0 && i_volume <= 200 )
 730     {
 731         i_vol = i_volume * AOUT_VOLUME_MAX / 200;
 732         aout_VolumeSet( p_libvlc, i_vol );
 733     }
 734     LIBVLC_FUNC_END;
 735     return i_vol * 200 / AOUT_VOLUME_MAX;
 736 }
 737
 738 /**
 739  * Get the current volume
 740  *
 741  * Retrieve the current volume.
 742  *
 743  * \param i_object a vlc object id
 744  * \return the current volume (range 0-200 %)
 745  */
 746 int VLC_VolumeGet( int i_object )
 747 {
 748     audio_volume_t i_volume;
 749     LIBVLC_FUNC;
 750     aout_VolumeGet( p_libvlc, &i_volume );
 751     LIBVLC_FUNC_END;
 752     return i_volume*200/AOUT_VOLUME_MAX;
 753 }
 754
 755 /**
 756  * Mute/Unmute the volume
 757  *
 758  * \param i_object a vlc object id
 759  * \return VLC_SUCCESS on success
 760  */
 761 int VLC_VolumeMute( int i_object )
 762 {
 763     LIBVLC_FUNC;
 764     aout_VolumeMute( p_libvlc, NULL );
 765     LIBVLC_FUNC_END;
 766     return VLC_SUCCESS;
 767 }
 768
 769 /*****************************************************************************
 770  * VLC_FullScreen: toggle fullscreen mode
 771  *****************************************************************************/
 772 int VLC_FullScreen( int i_object )
 773 {
 774     vout_thread_t *p_vout;
 775     LIBVLC_FUNC;
 776     p_vout = vlc_object_find( p_libvlc, VLC_OBJECT_VOUT, FIND_CHILD );
 777
 778     if( !p_vout )
 779     {
 780         if( i_object ) vlc_object_release( p_libvlc );
 781         return VLC_ENOOBJ;
 782     }
 783
 784     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 785     vlc_object_release( p_vout );
 786     LIBVLC_FUNC_END;
 787     return VLC_SUCCESS;
 788 }