1 /*****************************************************************************
2 * libvlc.c: Implementation of the old libvlc API
3 *****************************************************************************
4 * Copyright (C) 1998-2007 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 *****************************************************************************/
40 #include "control/libvlc_internal.h"
43 #include <vlc_playlist.h>
48 /*****************************************************************************
49 * VLC_Version: return the libvlc version.
50 *****************************************************************************
51 * This function returns full version string (numeric version and codename).
52 *****************************************************************************/
53 char const * VLC_Version( void )
55 return VERSION_MESSAGE
;
58 /*****************************************************************************
59 * VLC_CompileBy, VLC_CompileHost, VLC_CompileDomain,
60 * VLC_Compiler, VLC_Changeset
61 *****************************************************************************/
62 #define DECLARE_VLC_VERSION( func, var ) \
63 char const * VLC_##func ( void ) \
68 DECLARE_VLC_VERSION( CompileBy
, COMPILE_BY
);
69 DECLARE_VLC_VERSION( CompileHost
, COMPILE_HOST
);
70 DECLARE_VLC_VERSION( CompileDomain
, COMPILE_DOMAIN
);
71 DECLARE_VLC_VERSION( Compiler
, COMPILER
);
73 extern const char psz_vlc_changeset
[];
74 const char* VLC_Changeset( void )
76 return psz_vlc_changeset
;
79 /*****************************************************************************
80 * VLC_Error: strerror() equivalent
81 *****************************************************************************
82 * This function returns full version string (numeric version and codename).
83 *****************************************************************************/
84 char const * VLC_Error( int i_err
)
86 return vlc_error( i_err
);
89 /*****************************************************************************
90 * VLC_Create: allocate a libvlc instance and intialize global libvlc stuff if needed
91 *****************************************************************************
92 * This function allocates a libvlc instance and returns a negative value
93 * in case of failure. Also, the thread system is initialized.
94 *****************************************************************************/
95 int VLC_Create( void )
97 libvlc_int_t
*p_object
= libvlc_InternalCreate();
98 if( p_object
) return p_object
->i_object_id
;
102 #define LIBVLC_FUNC \
103 libvlc_int_t * p_libvlc = vlc_current_object( i_object ); \
104 if( !p_libvlc ) return VLC_ENOOBJ;
105 #define LIBVLC_FUNC_END \
106 if( i_object ) vlc_object_release( p_libvlc );
109 /*****************************************************************************
110 * VLC_Init: initialize a libvlc instance
111 *****************************************************************************
112 * This function initializes a previously allocated libvlc instance:
114 * - gettext initialization
115 * - message queue, module bank and playlist initialization
116 * - configuration and commandline parsing
117 *****************************************************************************/
118 int VLC_Init( int i_object
, int i_argc
, const char *ppsz_argv
[] )
122 i_ret
= libvlc_InternalInit( p_libvlc
, i_argc
, ppsz_argv
);
127 /*****************************************************************************
128 * VLC_AddIntf: add an interface
129 *****************************************************************************
130 * This function opens an interface plugin and runs it. If b_block is set
131 * to 0, VLC_AddIntf will return immediately and let the interface run in a
132 * separate thread. If b_block is set to 1, VLC_AddIntf will continue until
133 * user requests to quit. If b_play is set to 1, VLC_AddIntf will start playing
134 * the playlist when it is completely initialised.
135 *****************************************************************************/
136 int VLC_AddIntf( int i_object
, char const *psz_module
,
137 vlc_bool_t b_block
, vlc_bool_t b_play
)
141 i_ret
= libvlc_InternalAddIntf( p_libvlc
, psz_module
, b_block
, b_play
,
148 /*****************************************************************************
149 * VLC_Die: ask vlc to die.
150 *****************************************************************************
151 * This function sets p_libvlc->b_die to VLC_TRUE, but does not do any other
152 * task. It is your duty to call VLC_CleanUp and VLC_Destroy afterwards.
153 *****************************************************************************/
154 int VLC_Die( int i_object
)
157 vlc_object_kill( p_libvlc
);
162 /*****************************************************************************
163 * VLC_CleanUp: CleanUp all the intf, playlist, vout, aout
164 *****************************************************************************/
165 int VLC_CleanUp( int i_object
)
169 i_ret
= libvlc_InternalCleanup( p_libvlc
);
174 /*****************************************************************************
175 * VLC_Destroy: Destroy everything.
176 *****************************************************************************
177 * This function requests the running threads to finish, waits for their
178 * termination, and destroys their structure.
179 *****************************************************************************/
180 int VLC_Destroy( int i_object
)
183 return libvlc_InternalDestroy( p_libvlc
, i_object
? VLC_TRUE
: VLC_FALSE
);
186 /*****************************************************************************
187 * VLC_VariableSet: set a vlc variable
188 *****************************************************************************/
189 int VLC_VariableSet( int i_object
, char const *psz_var
, vlc_value_t value
)
194 /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
195 * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
196 if( !strncmp( psz_var
, "conf::", 6 ) )
198 module_config_t
*p_item
;
199 char const *psz_newvar
= psz_var
+ 6;
201 p_item
= config_FindConfig( VLC_OBJECT(p_libvlc
), psz_newvar
);
205 switch( p_item
->i_type
)
207 case CONFIG_ITEM_BOOL
:
208 config_PutInt( p_libvlc
, psz_newvar
, value
.b_bool
);
210 case CONFIG_ITEM_INTEGER
:
211 config_PutInt( p_libvlc
, psz_newvar
, value
.i_int
);
213 case CONFIG_ITEM_FLOAT
:
214 config_PutFloat( p_libvlc
, psz_newvar
, value
.f_float
);
217 config_PutPsz( p_libvlc
, psz_newvar
, value
.psz_string
);
220 if( i_object
) vlc_object_release( p_libvlc
);
225 i_ret
= var_Set( p_libvlc
, psz_var
, value
);
231 /*****************************************************************************
232 * VLC_VariableGet: get a vlc variable
233 *****************************************************************************/
234 int VLC_VariableGet( int i_object
, char const *psz_var
, vlc_value_t
*p_value
)
238 i_ret
= var_Get( p_libvlc
, psz_var
, p_value
);
243 /*****************************************************************************
244 * VLC_VariableType: get a vlc variable type
245 *****************************************************************************/
246 int VLC_VariableType( int i_object
, char const *psz_var
, int *pi_type
)
250 /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
251 * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
252 if( !strncmp( psz_var
, "conf::", 6 ) )
254 module_config_t
*p_item
;
255 char const *psz_newvar
= psz_var
+ 6;
257 p_item
= config_FindConfig( VLC_OBJECT(p_libvlc
), psz_newvar
);
261 switch( p_item
->i_type
)
263 case CONFIG_ITEM_BOOL
:
264 i_type
= VLC_VAR_BOOL
;
266 case CONFIG_ITEM_INTEGER
:
267 i_type
= VLC_VAR_INTEGER
;
269 case CONFIG_ITEM_FLOAT
:
270 i_type
= VLC_VAR_FLOAT
;
273 i_type
= VLC_VAR_STRING
;
281 i_type
= VLC_VAR_TYPE
& var_Type( p_libvlc
, psz_var
);
293 #define LIBVLC_PLAYLIST_FUNC \
294 libvlc_int_t *p_libvlc = vlc_current_object( i_object );\
295 if( !p_libvlc || !p_libvlc->p_playlist ) return VLC_ENOOBJ; \
296 vlc_object_yield( p_libvlc->p_playlist );
298 #define LIBVLC_PLAYLIST_FUNC_END \
299 vlc_object_release( p_libvlc->p_playlist ); \
300 if( i_object ) vlc_object_release( p_libvlc );
302 /*****************************************************************************
303 * VLC_AddTarget: adds a target for playing.
304 *****************************************************************************
305 * This function adds psz_target to the playlist
306 *****************************************************************************/
308 int VLC_AddTarget( int i_object
, char const *psz_target
,
309 char const **ppsz_options
, int i_options
,
310 int i_mode
, int i_pos
)
313 LIBVLC_PLAYLIST_FUNC
;
314 i_err
= playlist_AddExt( p_libvlc
->p_playlist
, psz_target
,
315 NULL
, i_mode
, i_pos
, -1,
316 ppsz_options
, i_options
, VLC_TRUE
, VLC_FALSE
);
317 LIBVLC_PLAYLIST_FUNC_END
;
321 /*****************************************************************************
322 * VLC_Play: play the playlist
323 *****************************************************************************/
324 int VLC_Play( int i_object
)
326 LIBVLC_PLAYLIST_FUNC
;
327 playlist_Play( p_libvlc
->p_playlist
);
328 LIBVLC_PLAYLIST_FUNC_END
;
332 /*****************************************************************************
333 * VLC_Pause: toggle pause
334 *****************************************************************************/
335 int VLC_Pause( int i_object
)
337 LIBVLC_PLAYLIST_FUNC
;
338 playlist_Pause( p_libvlc
->p_playlist
);
339 LIBVLC_PLAYLIST_FUNC_END
;
343 /*****************************************************************************
344 * VLC_Stop: stop playback
345 *****************************************************************************/
346 int VLC_Stop( int i_object
)
348 LIBVLC_PLAYLIST_FUNC
;
349 playlist_Stop( p_libvlc
->p_playlist
);
350 LIBVLC_PLAYLIST_FUNC_END
;
354 /*****************************************************************************
355 * VLC_IsPlaying: Query for Playlist Status
356 *****************************************************************************/
357 vlc_bool_t
VLC_IsPlaying( int i_object
)
359 vlc_bool_t b_playing
;
361 LIBVLC_PLAYLIST_FUNC
;
362 if( p_libvlc
->p_playlist
->p_input
)
365 var_Get( p_libvlc
->p_playlist
->p_input
, "state", &val
);
366 b_playing
= ( val
.i_int
== PLAYING_S
);
370 b_playing
= playlist_IsPlaying( p_libvlc
->p_playlist
);
372 LIBVLC_PLAYLIST_FUNC_END
;
377 * Get the current position in a input
379 * Return the current position as a float
380 * \note For some inputs, this will be unknown.
382 * \param i_object a vlc object id
383 * \return a float in the range of 0.0 - 1.0
385 float VLC_PositionGet( int i_object
)
387 input_thread_t
*p_input
;
391 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
395 if( i_object
) vlc_object_release( p_libvlc
);
399 var_Get( p_input
, "position", &val
);
400 vlc_object_release( p_input
);
407 * Set the current position in a input
409 * Set the current position in a input and then return
410 * the current position as a float.
411 * \note For some inputs, this will be unknown.
413 * \param i_object a vlc object id
414 * \param i_position a float in the range of 0.0 - 1.0
415 * \return a float in the range of 0.0 - 1.0
417 float VLC_PositionSet( int i_object
, float i_position
)
419 input_thread_t
*p_input
;
421 libvlc_int_t
*p_libvlc
= vlc_current_object( i_object
);
423 /* Check that the handle is valid */
429 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
433 if( i_object
) vlc_object_release( p_libvlc
);
437 val
.f_float
= i_position
;
438 var_Set( p_input
, "position", val
);
439 var_Get( p_input
, "position", &val
);
440 vlc_object_release( p_input
);
442 if( i_object
) vlc_object_release( p_libvlc
);
447 * Get the current position in a input
449 * Return the current position in seconds from the start.
450 * \note For some inputs, this will be unknown.
452 * \param i_object a vlc object id
453 * \return the offset from 0:00 in seconds
455 int VLC_TimeGet( int i_object
)
457 input_thread_t
*p_input
;
459 libvlc_int_t
*p_libvlc
= vlc_current_object( i_object
);
461 /* Check that the handle is valid */
467 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
471 if( i_object
) vlc_object_release( p_libvlc
);
475 var_Get( p_input
, "time", &val
);
476 vlc_object_release( p_input
);
478 if( i_object
) vlc_object_release( p_libvlc
);
479 return val
.i_time
/ 1000000;
483 * Seek to a position in the current input
485 * Seek i_seconds in the current input. If b_relative is set,
486 * then the seek will be relative to the current position, otherwise
487 * it will seek to i_seconds from the beginning of the input.
488 * \note For some inputs, this will be unknown.
490 * \param i_object a vlc object id
491 * \param i_seconds seconds from current position or from beginning of input
492 * \param b_relative seek relative from current position
493 * \return VLC_SUCCESS on success
495 int VLC_TimeSet( int i_object
, int i_seconds
, vlc_bool_t b_relative
)
497 input_thread_t
*p_input
;
499 libvlc_int_t
*p_libvlc
= vlc_current_object( i_object
);
501 /* Check that the handle is valid */
507 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
511 if( i_object
) vlc_object_release( p_libvlc
);
517 val
.i_time
= i_seconds
;
518 val
.i_time
= val
.i_time
* 1000000L;
519 var_Set( p_input
, "time-offset", val
);
523 val
.i_time
= i_seconds
;
524 val
.i_time
= val
.i_time
* 1000000L;
525 var_Set( p_input
, "time", val
);
527 vlc_object_release( p_input
);
529 if( i_object
) vlc_object_release( p_libvlc
);
534 * Get the total length of a input
536 * Return the total length in seconds from the current input.
537 * \note For some inputs, this will be unknown.
539 * \param i_object a vlc object id
540 * \return the length in seconds
542 int VLC_LengthGet( int i_object
)
544 input_thread_t
*p_input
;
546 libvlc_int_t
*p_libvlc
= vlc_current_object( i_object
);
548 /* Check that the handle is valid */
554 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
558 if( i_object
) vlc_object_release( p_libvlc
);
562 var_Get( p_input
, "length", &val
);
563 vlc_object_release( p_input
);
565 if( i_object
) vlc_object_release( p_libvlc
);
566 return val
.i_time
/ 1000000L;
570 * Play the input faster than realtime
572 * 2x, 4x, 8x faster than realtime
573 * \note For some inputs, this will be impossible.
575 * \param i_object a vlc object id
576 * \return the current speedrate
578 float VLC_SpeedFaster( int i_object
)
580 input_thread_t
*p_input
;
582 libvlc_int_t
*p_libvlc
= vlc_current_object( i_object
);
584 /* Check that the handle is valid */
590 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
594 if( i_object
) vlc_object_release( p_libvlc
);
598 val
.b_bool
= VLC_TRUE
;
599 var_Set( p_input
, "rate-faster", val
);
600 var_Get( p_input
, "rate", &val
);
601 vlc_object_release( p_input
);
603 if( i_object
) vlc_object_release( p_libvlc
);
604 return val
.f_float
/ INPUT_RATE_DEFAULT
;
608 * Play the input slower than realtime
610 * 1/2x, 1/4x, 1/8x slower than realtime
611 * \note For some inputs, this will be impossible.
613 * \param i_object a vlc object id
614 * \return the current speedrate
616 float VLC_SpeedSlower( int i_object
)
618 input_thread_t
*p_input
;
620 libvlc_int_t
*p_libvlc
= vlc_current_object( i_object
);
622 /* Check that the handle is valid */
628 p_input
= vlc_object_find( p_libvlc
, VLC_OBJECT_INPUT
, FIND_CHILD
);
632 if( i_object
) vlc_object_release( p_libvlc
);
636 val
.b_bool
= VLC_TRUE
;
637 var_Set( p_input
, "rate-slower", val
);
638 var_Get( p_input
, "rate", &val
);
639 vlc_object_release( p_input
);
641 if( i_object
) vlc_object_release( p_libvlc
);
642 return val
.f_float
/ INPUT_RATE_DEFAULT
;
646 * Return the current playlist item
648 * Returns the index of the playlistitem that is currently selected for play.
649 * This is valid even if nothing is currently playing.
651 * \param i_object a vlc object id
652 * \return the current index
654 int VLC_PlaylistIndex( int i_object
)
657 printf( "This function is deprecated and should not be used anymore" );
662 * Total number of items in the playlist
664 * \param i_object a vlc object id
665 * \return amount of playlist items
667 int VLC_PlaylistNumberOfItems( int i_object
)
670 LIBVLC_PLAYLIST_FUNC
;
671 i_size
= p_libvlc
->p_playlist
->items
.i_size
;
672 LIBVLC_PLAYLIST_FUNC_END
;
677 * Go to next playlist item
678 * \param i_object a vlc object id
679 * \return VLC_SUCCESS on success
681 int VLC_PlaylistNext( int i_object
)
683 LIBVLC_PLAYLIST_FUNC
;
684 playlist_Next( p_libvlc
->p_playlist
);
685 LIBVLC_PLAYLIST_FUNC_END
;
690 * Go to previous playlist item
691 * \param i_object a vlc object id
692 * \return VLC_SUCCESS on success
694 int VLC_PlaylistPrev( int i_object
)
696 LIBVLC_PLAYLIST_FUNC
;
697 playlist_Prev( p_libvlc
->p_playlist
);
698 LIBVLC_PLAYLIST_FUNC_END
;
705 int VLC_PlaylistClear( int i_object
)
707 LIBVLC_PLAYLIST_FUNC
;
708 playlist_Clear( p_libvlc
->p_playlist
, VLC_TRUE
);
709 LIBVLC_PLAYLIST_FUNC_END
;
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 %)
720 int VLC_VolumeSet( int i_object
, int i_volume
)
722 audio_volume_t i_vol
= 0;
725 if( i_volume
>= 0 && i_volume
<= 200 )
727 i_vol
= i_volume
* AOUT_VOLUME_MAX
/ 200;
728 aout_VolumeSet( p_libvlc
, i_vol
);
731 return i_vol
* 200 / AOUT_VOLUME_MAX
;
735 * Get the current volume
737 * Retrieve the current volume.
739 * \param i_object a vlc object id
740 * \return the current volume (range 0-200 %)
742 int VLC_VolumeGet( int i_object
)
744 audio_volume_t i_volume
;
746 aout_VolumeGet( p_libvlc
, &i_volume
);
748 return i_volume
*200/AOUT_VOLUME_MAX
;
752 * Mute/Unmute the volume
754 * \param i_object a vlc object id
755 * \return VLC_SUCCESS on success
757 int VLC_VolumeMute( int i_object
)
760 aout_VolumeMute( p_libvlc
, NULL
);
765 /*****************************************************************************
766 * VLC_FullScreen: toggle fullscreen mode
767 *****************************************************************************/
768 int VLC_FullScreen( int i_object
)
770 vout_thread_t
*p_vout
;
772 p_vout
= vlc_object_find( p_libvlc
, VLC_OBJECT_VOUT
, FIND_CHILD
);
776 if( i_object
) vlc_object_release( p_libvlc
);
780 p_vout
->i_changes
|= VOUT_FULLSCREEN_CHANGE
;
781 vlc_object_release( p_vout
);