1 /*****************************************************************************
2 * libvlc.c: Implementation of the old libvlc API
3 *****************************************************************************
4 * Copyright (C) 1998-2006 the VideoLAN team
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>
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.
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.
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 *****************************************************************************/
28 /*****************************************************************************
29 * Pretend we are a builtin module
30 *****************************************************************************/
31 #define MODULE_NAME main
32 #define MODULE_PATH main
35 /*****************************************************************************
37 *****************************************************************************/
39 #include <vlc/input.h>
41 #include <libvlc_internal.h>
43 #include <vlc_error.h>
44 #include <vlc_playlist.h>
46 #include "audio_output.h"
47 #include "vlc_video.h"
48 #include "video_output.h"
50 /*****************************************************************************
51 * VLC_Version: return the libvlc version.
52 *****************************************************************************
53 * This function returns full version string (numeric version and codename).
54 *****************************************************************************/
55 char const * VLC_Version( void )
57 return VERSION_MESSAGE;
60 /*****************************************************************************
61 * VLC_CompileBy, VLC_CompileHost, VLC_CompileDomain,
62 * VLC_Compiler, VLC_Changeset
63 *****************************************************************************/
64 #define DECLARE_VLC_VERSION( func, var ) \
65 char const * VLC_##func ( void ) \
70 DECLARE_VLC_VERSION( CompileBy, COMPILE_BY );
71 DECLARE_VLC_VERSION( CompileHost, COMPILE_HOST );
72 DECLARE_VLC_VERSION( CompileDomain, COMPILE_DOMAIN );
73 DECLARE_VLC_VERSION( Compiler, COMPILER );
75 #ifndef HAVE_SHARED_LIBVLC
76 extern const char psz_vlc_changeset[];
77 char const * VLC_Changeset( void )
79 return psz_vlc_changeset;
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 )
90 return vlc_error( i_err );
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 )
101 libvlc_int_t *p_object = libvlc_InternalCreate();
102 if( p_object ) return p_object->i_object_id;
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 );
113 /*****************************************************************************
114 * VLC_Init: initialize a libvlc instance
115 *****************************************************************************
116 * This function initializes a previously allocated libvlc instance:
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, char *ppsz_argv[] )
126 i_ret = libvlc_InternalInit( p_libvlc, i_argc, ppsz_argv );
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 )
145 i_ret = libvlc_InternalAddIntf( p_libvlc, psz_module, b_block, b_play,
152 /*****************************************************************************
153 * VLC_Die: ask vlc to die.
154 *****************************************************************************
155 * This function sets p_vlc->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 )
161 p_libvlc->b_die = VLC_TRUE;
166 /*****************************************************************************
167 * VLC_CleanUp: CleanUp all the intf, playlist, vout, aout
168 *****************************************************************************/
169 int VLC_CleanUp( int i_object )
173 i_ret = libvlc_InternalCleanup( p_libvlc );
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 )
187 return libvlc_InternalDestroy( p_libvlc, i_object ? VLC_TRUE : VLC_FALSE );
190 /*****************************************************************************
191 * VLC_VariableSet: set a vlc variable
192 *****************************************************************************/
193 int VLC_VariableSet( int i_object, char const *psz_var, vlc_value_t value )
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 ) )
202 module_config_t *p_item;
203 char const *psz_newvar = psz_var + 6;
205 p_item = config_FindConfig( VLC_OBJECT(p_libvlc), psz_newvar );
209 switch( p_item->i_type )
211 case CONFIG_ITEM_BOOL:
212 config_PutInt( p_libvlc, psz_newvar, value.b_bool );
214 case CONFIG_ITEM_INTEGER:
215 config_PutInt( p_libvlc, psz_newvar, value.i_int );
217 case CONFIG_ITEM_FLOAT:
218 config_PutFloat( p_libvlc, psz_newvar, value.f_float );
221 config_PutPsz( p_libvlc, psz_newvar, value.psz_string );
224 if( i_object ) vlc_object_release( p_libvlc );
229 i_ret = var_Set( p_libvlc, psz_var, value );
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 )
242 i_ret = var_Get( p_libvlc , psz_var, p_value );
247 /*****************************************************************************
248 * VLC_VariableType: get a vlc variable type
249 *****************************************************************************/
250 int VLC_VariableType( int i_object, char const *psz_var, int *pi_type )
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 ) )
258 module_config_t *p_item;
259 char const *psz_newvar = psz_var + 6;
261 p_item = config_FindConfig( VLC_OBJECT(p_libvlc), psz_newvar );
265 switch( p_item->i_type )
267 case CONFIG_ITEM_BOOL:
268 i_type = VLC_VAR_BOOL;
270 case CONFIG_ITEM_INTEGER:
271 i_type = VLC_VAR_INTEGER;
273 case CONFIG_ITEM_FLOAT:
274 i_type = VLC_VAR_FLOAT;
277 i_type = VLC_VAR_STRING;
285 i_type = VLC_VAR_TYPE & var_Type( p_libvlc , psz_var );
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 );
302 #define LIBVLC_PLAYLIST_FUNC_END \
303 vlc_object_release( p_libvlc->p_playlist ); \
304 if( i_object ) vlc_object_release( p_libvlc );
306 /*****************************************************************************
307 * VLC_AddTarget: adds a target for playing.
308 *****************************************************************************
309 * This function adds psz_target to the playlist
310 *****************************************************************************/
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 )
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 );
321 LIBVLC_PLAYLIST_FUNC_END;
325 /*****************************************************************************
326 * VLC_Play: play the playlist
327 *****************************************************************************/
328 int VLC_Play( int i_object )
330 LIBVLC_PLAYLIST_FUNC;
331 playlist_Play( p_libvlc->p_playlist );
332 LIBVLC_PLAYLIST_FUNC_END;
336 /*****************************************************************************
337 * VLC_Pause: toggle pause
338 *****************************************************************************/
339 int VLC_Pause( int i_object )
341 LIBVLC_PLAYLIST_FUNC;
342 playlist_Pause( p_libvlc->p_playlist );
343 LIBVLC_PLAYLIST_FUNC_END;
347 /*****************************************************************************
348 * VLC_Stop: stop playback
349 *****************************************************************************/
350 int VLC_Stop( int i_object )
352 LIBVLC_PLAYLIST_FUNC;
353 playlist_Stop( p_libvlc->p_playlist );
354 LIBVLC_PLAYLIST_FUNC_END;
358 /*****************************************************************************
359 * VLC_IsPlaying: Query for Playlist Status
360 *****************************************************************************/
361 vlc_bool_t VLC_IsPlaying( int i_object )
363 vlc_bool_t b_playing;
365 LIBVLC_PLAYLIST_FUNC;
366 if( p_libvlc->p_playlist->p_input )
369 var_Get( p_libvlc->p_playlist->p_input, "state", &val );
370 b_playing = ( val.i_int == PLAYING_S );
374 b_playing = playlist_IsPlaying( p_libvlc->p_playlist );
376 LIBVLC_PLAYLIST_FUNC_END;
381 * Get the current position in a input
383 * Return the current position as a float
384 * \note For some inputs, this will be unknown.
386 * \param i_object a vlc object id
387 * \return a float in the range of 0.0 - 1.0
389 float VLC_PositionGet( int i_object )
391 input_thread_t *p_input;
395 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
399 if( i_object ) vlc_object_release( p_libvlc );
403 var_Get( p_input, "position", &val );
404 vlc_object_release( p_input );
411 * Set the current position in a input
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.
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
421 float VLC_PositionSet( int i_object, float i_position )
423 input_thread_t *p_input;
425 libvlc_int_t *p_libvlc = vlc_current_object( i_object );
427 /* Check that the handle is valid */
433 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
437 if( i_object ) vlc_object_release( p_libvlc );
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 );
446 if( i_object ) vlc_object_release( p_libvlc );
451 * Get the current position in a input
453 * Return the current position in seconds from the start.
454 * \note For some inputs, this will be unknown.
456 * \param i_object a vlc object id
457 * \return the offset from 0:00 in seconds
459 int VLC_TimeGet( int i_object )
461 input_thread_t *p_input;
463 libvlc_int_t *p_libvlc = vlc_current_object( i_object );
465 /* Check that the handle is valid */
471 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
475 if( i_object ) vlc_object_release( p_libvlc );
479 var_Get( p_input, "time", &val );
480 vlc_object_release( p_input );
482 if( i_object ) vlc_object_release( p_libvlc );
483 return val.i_time / 1000000;
487 * Seek to a position in the current input
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.
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
499 int VLC_TimeSet( int i_object, int i_seconds, vlc_bool_t b_relative )
501 input_thread_t *p_input;
503 libvlc_int_t *p_libvlc = vlc_current_object( i_object );
505 /* Check that the handle is valid */
511 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
515 if( i_object ) vlc_object_release( p_libvlc );
521 val.i_time = i_seconds;
522 val.i_time = val.i_time * 1000000L;
523 var_Set( p_input, "time-offset", val );
527 val.i_time = i_seconds;
528 val.i_time = val.i_time * 1000000L;
529 var_Set( p_input, "time", val );
531 vlc_object_release( p_input );
533 if( i_object ) vlc_object_release( p_libvlc );
538 * Get the total length of a input
540 * Return the total length in seconds from the current input.
541 * \note For some inputs, this will be unknown.
543 * \param i_object a vlc object id
544 * \return the length in seconds
546 int VLC_LengthGet( int i_object )
548 input_thread_t *p_input;
550 libvlc_int_t *p_libvlc = vlc_current_object( i_object );
552 /* Check that the handle is valid */
558 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
562 if( i_object ) vlc_object_release( p_libvlc );
566 var_Get( p_input, "length", &val );
567 vlc_object_release( p_input );
569 if( i_object ) vlc_object_release( p_libvlc );
570 return val.i_time / 1000000L;
574 * Play the input faster than realtime
576 * 2x, 4x, 8x faster than realtime
577 * \note For some inputs, this will be impossible.
579 * \param i_object a vlc object id
580 * \return the current speedrate
582 float VLC_SpeedFaster( int i_object )
584 input_thread_t *p_input;
586 libvlc_int_t *p_libvlc = vlc_current_object( i_object );
588 /* Check that the handle is valid */
594 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
598 if( i_object ) vlc_object_release( p_libvlc );
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 );
607 if( i_object ) vlc_object_release( p_libvlc );
608 return val.f_float / INPUT_RATE_DEFAULT;
612 * Play the input slower than realtime
614 * 1/2x, 1/4x, 1/8x slower than realtime
615 * \note For some inputs, this will be impossible.
617 * \param i_object a vlc object id
618 * \return the current speedrate
620 float VLC_SpeedSlower( int i_object )
622 input_thread_t *p_input;
624 libvlc_int_t *p_libvlc = vlc_current_object( i_object );
626 /* Check that the handle is valid */
632 p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD );
636 if( i_object ) vlc_object_release( p_libvlc );
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 );
645 if( i_object ) vlc_object_release( p_libvlc );
646 return val.f_float / INPUT_RATE_DEFAULT;
650 * Return the current playlist item
652 * Returns the index of the playlistitem that is currently selected for play.
653 * This is valid even if nothing is currently playing.
655 * \param i_object a vlc object id
656 * \return the current index
658 int VLC_PlaylistIndex( int i_object )
660 printf( "This function is deprecated and should not be used anymore" );
665 * Total number of items in the playlist
667 * \param i_object a vlc object id
668 * \return amount of playlist items
670 int VLC_PlaylistNumberOfItems( int i_object )
673 LIBVLC_PLAYLIST_FUNC;
674 i_size = p_libvlc->p_playlist->items.i_size;
675 LIBVLC_PLAYLIST_FUNC_END;
680 * Go to next playlist item
681 * \param i_object a vlc object id
682 * \return VLC_SUCCESS on success
684 int VLC_PlaylistNext( int i_object )
686 LIBVLC_PLAYLIST_FUNC;
687 playlist_Next( p_libvlc->p_playlist );
688 LIBVLC_PLAYLIST_FUNC_END;
693 * Go to previous playlist item
694 * \param i_object a vlc object id
695 * \return VLC_SUCCESS on success
697 int VLC_PlaylistPrev( int i_object )
699 LIBVLC_PLAYLIST_FUNC;
700 playlist_Prev( p_libvlc->p_playlist );
701 LIBVLC_PLAYLIST_FUNC_END;
708 int VLC_PlaylistClear( int i_object )
710 LIBVLC_PLAYLIST_FUNC;
711 playlist_Clear( p_libvlc->p_playlist );
712 LIBVLC_PLAYLIST_FUNC_END;
719 * \param i_object a vlc object id
720 * \param i_volume something in a range from 0-200
721 * \return the new volume (range 0-200 %)
723 int VLC_VolumeSet( int i_object, int i_volume )
725 audio_volume_t i_vol = 0;
728 if( i_volume >= 0 && i_volume <= 200 )
730 i_vol = i_volume * AOUT_VOLUME_MAX / 200;
731 aout_VolumeSet( p_libvlc, i_vol );
734 return i_vol * 200 / AOUT_VOLUME_MAX;
738 * Get the current volume
740 * Retrieve the current volume.
742 * \param i_object a vlc object id
743 * \return the current volume (range 0-200 %)
745 int VLC_VolumeGet( int i_object )
747 audio_volume_t i_volume;
749 aout_VolumeGet( p_libvlc, &i_volume );
751 return i_volume*200/AOUT_VOLUME_MAX;
755 * Mute/Unmute the volume
757 * \param i_object a vlc object id
758 * \return VLC_SUCCESS on success
760 int VLC_VolumeMute( int i_object )
763 aout_VolumeMute( p_libvlc, NULL );
768 /*****************************************************************************
769 * VLC_FullScreen: toggle fullscreen mode
770 *****************************************************************************/
771 int VLC_FullScreen( int i_object )
773 vout_thread_t *p_vout;
775 p_vout = vlc_object_find( p_libvlc, VLC_OBJECT_VOUT, FIND_CHILD );
779 if( i_object ) vlc_object_release( p_libvlc );
783 p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
784 vlc_object_release( p_vout );