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