video.c: don't display pre-rolled pictures
[vlc.git] / src / libvlc.c
1 /*****************************************************************************
2  * libvlc.c: main libvlc source
3  *****************************************************************************
4  * Copyright (C) 1998-2004 VideoLAN
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  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Pretend we are a builtin module
29  *****************************************************************************/
30 #define MODULE_NAME main
31 #define MODULE_PATH main
32 #define __BUILTIN__
33
34 /*****************************************************************************
35  * Preamble
36  *****************************************************************************/
37 #include <vlc/vlc.h>
38 #include <vlc/input.h>
39
40 #include <errno.h>                                                 /* ENOMEM */
41 #include <stdio.h>                                              /* sprintf() */
42 #include <string.h>                                            /* strerror() */
43 #include <stdlib.h>                                                /* free() */
44
45 #ifndef WIN32
46 #   include <netinet/in.h>                            /* BSD: struct in_addr */
47 #endif
48
49 #ifdef HAVE_UNISTD_H
50 #   include <unistd.h>
51 #elif defined( WIN32 ) && !defined( UNDER_CE )
52 #   include <io.h>
53 #endif
54
55 #ifdef WIN32                       /* optind, getopt(), included in unistd.h */
56 #   include "extras/getopt.h"
57 #endif
58
59 #ifdef HAVE_LOCALE_H
60 #   include <locale.h>
61 #endif
62
63 #ifdef HAVE_HAL
64 #   include <hal/libhal.h>
65 #endif
66
67 #include "vlc_cpu.h"                                        /* CPU detection */
68 #include "os_specific.h"
69
70 #include "vlc_error.h"
71
72 #include "vlc_playlist.h"
73 #include "vlc_interface.h"
74
75 #include "audio_output.h"
76
77 #include "vlc_video.h"
78 #include "video_output.h"
79
80 #include "stream_output.h"
81
82 #include "libvlc.h"
83
84 /*****************************************************************************
85  * The evil global variable. We handle it with care, don't worry.
86  *****************************************************************************/
87 static libvlc_t   libvlc;
88 static libvlc_t * p_libvlc;
89 static vlc_t *    p_static_vlc;
90
91 /*****************************************************************************
92  * Local prototypes
93  *****************************************************************************/
94 static void SetLanguage   ( char const * );
95 static int  GetFilenames  ( vlc_t *, int, char *[] );
96 static void Usage         ( vlc_t *, char const *psz_module_name );
97 static void ListModules   ( vlc_t * );
98 static void Version       ( void );
99
100 #ifdef WIN32
101 static void ShowConsole   ( void );
102 static void PauseConsole  ( void );
103 #endif
104 static int  ConsoleWidth  ( void );
105
106 static int  VerboseCallback( vlc_object_t *, char const *,
107                              vlc_value_t, vlc_value_t, void * );
108
109 static void InitDeviceValues( vlc_t * );
110
111 /*****************************************************************************
112  * vlc_current_object: return the current object.
113  *****************************************************************************
114  * If i_object is non-zero, return the corresponding object. Otherwise,
115  * return the statically allocated p_vlc object.
116  *****************************************************************************/
117 vlc_t * vlc_current_object( int i_object )
118 {
119     if( i_object )
120     {
121          return vlc_object_get( p_libvlc, i_object );
122     }
123
124     return p_static_vlc;
125 }
126
127 /*****************************************************************************
128  * VLC_Version: return the libvlc version.
129  *****************************************************************************
130  * This function returns full version string (numeric version and codename).
131  *****************************************************************************/
132 char const * VLC_Version( void )
133 {
134     return VERSION_MESSAGE;
135 }
136
137 /*****************************************************************************
138  * VLC_Error: strerror() equivalent
139  *****************************************************************************
140  * This function returns full version string (numeric version and codename).
141  *****************************************************************************/
142 char const * VLC_Error( int i_err )
143 {
144     return vlc_error( i_err );
145 }
146
147 /*****************************************************************************
148  * VLC_Create: allocate a vlc_t structure, and initialize libvlc if needed.
149  *****************************************************************************
150  * This function allocates a vlc_t structure and returns a negative value
151  * in case of failure. Also, the thread system is initialized.
152  *****************************************************************************/
153 int VLC_Create( void )
154 {
155     int i_ret;
156     vlc_t * p_vlc = NULL;
157     vlc_value_t lockval;
158
159     /* &libvlc never changes, so we can safely call this multiple times. */
160     p_libvlc = &libvlc;
161
162     /* vlc_threads_init *must* be the first internal call! No other call is
163      * allowed before the thread system has been initialized. */
164     i_ret = vlc_threads_init( p_libvlc );
165     if( i_ret < 0 )
166     {
167         return i_ret;
168     }
169
170     /* Now that the thread system is initialized, we don't have much, but
171      * at least we have var_Create */
172     var_Create( p_libvlc, "libvlc", VLC_VAR_MUTEX );
173     var_Get( p_libvlc, "libvlc", &lockval );
174     vlc_mutex_lock( lockval.p_address );
175     if( !libvlc.b_ready )
176     {
177         char *psz_env;
178
179         /* Guess what CPU we have */
180         libvlc.i_cpu = CPUCapabilities();
181
182         /* Find verbosity from VLC_VERBOSE environment variable */
183         psz_env = getenv( "VLC_VERBOSE" );
184         libvlc.i_verbose = psz_env ? atoi( psz_env ) : -1;
185
186 #if defined( HAVE_ISATTY ) && !defined( WIN32 )
187         libvlc.b_color = isatty( 2 ); /* 2 is for stderr */
188 #else
189         libvlc.b_color = VLC_FALSE;
190 #endif
191
192         /* Initialize message queue */
193         msg_Create( p_libvlc );
194
195         /* Announce who we are */
196         msg_Dbg( p_libvlc, COPYRIGHT_MESSAGE );
197         msg_Dbg( p_libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
198
199         /* The module bank will be initialized later */
200         libvlc.p_module_bank = NULL;
201
202         libvlc.b_ready = VLC_TRUE;
203     }
204     vlc_mutex_unlock( lockval.p_address );
205     var_Destroy( p_libvlc, "libvlc" );
206
207     /* Allocate a vlc object */
208     p_vlc = vlc_object_create( p_libvlc, VLC_OBJECT_VLC );
209     if( p_vlc == NULL )
210     {
211         return VLC_EGENERIC;
212     }
213     p_vlc->thread_id = 0;
214
215     p_vlc->psz_object_name = "root";
216
217     /* Initialize mutexes */
218     vlc_mutex_init( p_vlc, &p_vlc->config_lock );
219 #ifdef SYS_DARWIN
220     vlc_mutex_init( p_vlc, &p_vlc->quicktime_lock );
221     vlc_thread_set_priority( p_vlc, VLC_THREAD_PRIORITY_LOW );
222 #endif
223
224     /* Store our newly allocated structure in the global list */
225     vlc_object_attach( p_vlc, p_libvlc );
226
227     /* Store data for the non-reentrant API */
228     p_static_vlc = p_vlc;
229
230     return p_vlc->i_object_id;
231 }
232
233 /*****************************************************************************
234  * VLC_Init: initialize a vlc_t structure.
235  *****************************************************************************
236  * This function initializes a previously allocated vlc_t structure:
237  *  - CPU detection
238  *  - gettext initialization
239  *  - message queue, module bank and playlist initialization
240  *  - configuration and commandline parsing
241  *****************************************************************************/
242 int VLC_Init( int i_object, int i_argc, char *ppsz_argv[] )
243 {
244     char         p_capabilities[200];
245     char *       p_tmp;
246     char *       psz_modules;
247     char *       psz_parser;
248     char *       psz_control;
249     char *       psz_language;
250     vlc_bool_t   b_exit = VLC_FALSE;
251     vlc_t *      p_vlc = vlc_current_object( i_object );
252     module_t    *p_help_module;
253     playlist_t  *p_playlist;
254
255     if( !p_vlc )
256     {
257         return VLC_ENOOBJ;
258     }
259
260     /*
261      * System specific initialization code
262      */
263     system_Init( p_vlc, &i_argc, ppsz_argv );
264
265     /* Get the executable name (similar to the basename command) */
266     if( i_argc > 0 )
267     {
268         p_vlc->psz_object_name = p_tmp = ppsz_argv[ 0 ];
269         while( *p_tmp )
270         {
271             if( *p_tmp == '/' ) p_vlc->psz_object_name = ++p_tmp;
272             else ++p_tmp;
273         }
274     }
275     else
276     {
277         p_vlc->psz_object_name = "vlc";
278     }
279
280     /*
281      * Support for gettext
282      */
283     SetLanguage( "" );
284
285     /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
286     msg_Dbg( p_vlc, "translation test: code is \"%s\"", _("C") );
287
288     /* Initialize the module bank and load the configuration of the
289      * main module. We need to do this at this stage to be able to display
290      * a short help if required by the user. (short help == main module
291      * options) */
292     module_InitBank( p_vlc );
293
294     /* Hack: insert the help module here */
295     p_help_module = vlc_object_create( p_vlc, VLC_OBJECT_MODULE );
296     if( p_help_module == NULL )
297     {
298         module_EndBank( p_vlc );
299         if( i_object ) vlc_object_release( p_vlc );
300         return VLC_EGENERIC;
301     }
302     p_help_module->psz_object_name = "help";
303     p_help_module->psz_longname = N_("Help options");
304     config_Duplicate( p_help_module, p_help_config );
305     vlc_object_attach( p_help_module, libvlc.p_module_bank );
306     /* End hack */
307
308     if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE ) )
309     {
310         vlc_object_detach( p_help_module );
311         config_Free( p_help_module );
312         vlc_object_destroy( p_help_module );
313         module_EndBank( p_vlc );
314         if( i_object ) vlc_object_release( p_vlc );
315         return VLC_EGENERIC;
316     }
317
318     /* Check for short help option */
319     if( config_GetInt( p_vlc, "help" ) )
320     {
321         fprintf( stdout, _("Usage: %s [options] [items]...\n"),
322                          p_vlc->psz_object_name );
323         Usage( p_vlc, "main" );
324         Usage( p_vlc, "help" );
325         b_exit = VLC_TRUE;
326     }
327     /* Check for version option */
328     else if( config_GetInt( p_vlc, "version" ) )
329     {
330         Version();
331         b_exit = VLC_TRUE;
332     }
333
334     /* Set the config file stuff */
335     p_vlc->psz_homedir = config_GetHomeDir();
336     p_vlc->psz_configfile = config_GetPsz( p_vlc, "config" );
337
338     /* Check for plugins cache options */
339     if( config_GetInt( p_vlc, "reset-plugins-cache" ) )
340     {
341         libvlc.p_module_bank->b_cache_delete = VLC_TRUE;
342     }
343
344     /* Hack: remove the help module here */
345     vlc_object_detach( p_help_module );
346     /* End hack */
347
348     /* Will be re-done properly later on */
349     p_vlc->p_libvlc->i_verbose = config_GetInt( p_vlc, "verbose" );
350
351     /* Check for daemon mode */
352 #ifndef WIN32
353     if( config_GetInt( p_vlc, "daemon" ) )
354     {
355 #if HAVE_DAEMON
356         if( daemon( 0, 0) != 0 )
357         {
358             msg_Err( p_vlc, "Unable to fork vlc to daemon mode" );
359             b_exit = VLC_TRUE;
360         }
361
362         p_vlc->p_libvlc->b_daemon = VLC_TRUE;
363
364 #else
365         pid_t i_pid;
366
367         if( ( i_pid = fork() ) < 0 )
368         {
369             msg_Err( p_vlc, "Unable to fork vlc to daemon mode" );
370             b_exit = VLC_TRUE;
371         }
372         else if( i_pid )
373         {
374             /* This is the parent, exit right now */
375             msg_Dbg( p_vlc, "closing parent process" );
376             b_exit = VLC_TRUE;
377         }
378         else
379         {
380             /* We are the child */
381             msg_Dbg( p_vlc, "daemon spawned" );
382             close( STDIN_FILENO );
383             close( STDOUT_FILENO );
384             close( STDERR_FILENO );
385
386             p_vlc->p_libvlc->b_daemon = VLC_TRUE;
387         }
388 #endif
389     }
390 #endif
391
392     if( b_exit )
393     {
394         config_Free( p_help_module );
395         vlc_object_destroy( p_help_module );
396         module_EndBank( p_vlc );
397         if( i_object ) vlc_object_release( p_vlc );
398         return VLC_EEXIT;
399     }
400
401     /* Check for translation config option */
402 #if defined( ENABLE_NLS ) \
403      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
404
405     /* This ain't really nice to have to reload the config here but it seems
406      * the only way to do it. */
407     config_LoadConfigFile( p_vlc, "main" );
408     config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
409
410     /* Check if the user specified a custom language */
411     psz_language = config_GetPsz( p_vlc, "language" );
412     if( psz_language && *psz_language && strcmp( psz_language, "auto" ) )
413     {
414         vlc_bool_t b_cache_delete = libvlc.p_module_bank->b_cache_delete;
415
416         /* Reset the default domain */
417         SetLanguage( psz_language );
418
419         /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
420         msg_Dbg( p_vlc, "translation test: code is \"%s\"", _("C") );
421
422         textdomain( PACKAGE_NAME );
423
424 #if defined( ENABLE_UTF8 )
425         bind_textdomain_codeset( PACKAGE_NAME, "UTF-8" );
426 #endif
427
428         module_EndBank( p_vlc );
429         module_InitBank( p_vlc );
430         config_LoadConfigFile( p_vlc, "main" );
431         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
432         libvlc.p_module_bank->b_cache_delete = b_cache_delete;
433     }
434     if( psz_language ) free( psz_language );
435 #endif
436
437     /*
438      * Load the builtins and plugins into the module_bank.
439      * We have to do it before config_Load*() because this also gets the
440      * list of configuration options exported by each module and loads their
441      * default values.
442      */
443     module_LoadBuiltins( p_vlc );
444     module_LoadPlugins( p_vlc );
445     if( p_vlc->b_die )
446     {
447         b_exit = VLC_TRUE;
448     }
449
450     msg_Dbg( p_vlc, "module bank initialized, found %i modules",
451                     libvlc.p_module_bank->i_children );
452
453     /* Hack: insert the help module here */
454     vlc_object_attach( p_help_module, libvlc.p_module_bank );
455     /* End hack */
456
457     /* Check for help on modules */
458     if( (p_tmp = config_GetPsz( p_vlc, "module" )) )
459     {
460         Usage( p_vlc, p_tmp );
461         free( p_tmp );
462         b_exit = VLC_TRUE;
463     }
464     /* Check for long help option */
465     else if( config_GetInt( p_vlc, "longhelp" ) )
466     {
467         Usage( p_vlc, NULL );
468         b_exit = VLC_TRUE;
469     }
470     /* Check for module list option */
471     else if( config_GetInt( p_vlc, "list" ) )
472     {
473         ListModules( p_vlc );
474         b_exit = VLC_TRUE;
475     }
476
477     /* Check for config file options */
478     if( config_GetInt( p_vlc, "reset-config" ) )
479     {
480         vlc_object_detach( p_help_module );
481         config_ResetAll( p_vlc );
482         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
483         config_SaveConfigFile( p_vlc, NULL );
484         vlc_object_attach( p_help_module, libvlc.p_module_bank );
485     }
486     if( config_GetInt( p_vlc, "save-config" ) )
487     {
488         vlc_object_detach( p_help_module );
489         config_LoadConfigFile( p_vlc, NULL );
490         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
491         config_SaveConfigFile( p_vlc, NULL );
492         vlc_object_attach( p_help_module, libvlc.p_module_bank );
493     }
494
495     /* Hack: remove the help module here */
496     vlc_object_detach( p_help_module );
497     /* End hack */
498
499     if( b_exit )
500     {
501         config_Free( p_help_module );
502         vlc_object_destroy( p_help_module );
503         module_EndBank( p_vlc );
504         if( i_object ) vlc_object_release( p_vlc );
505         return VLC_EEXIT;
506     }
507
508     /*
509      * Init device values
510      */
511     InitDeviceValues( p_vlc );
512
513     /*
514      * Override default configuration with config file settings
515      */
516     config_LoadConfigFile( p_vlc, NULL );
517
518     /* Hack: insert the help module here */
519     vlc_object_attach( p_help_module, libvlc.p_module_bank );
520     /* End hack */
521
522     /*
523      * Override configuration with command line settings
524      */
525     if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_FALSE ) )
526     {
527 #ifdef WIN32
528         ShowConsole();
529         /* Pause the console because it's destroyed when we exit */
530         fprintf( stderr, "The command line options couldn't be loaded, check "
531                  "that they are valid.\n" );
532         PauseConsole();
533 #endif
534         vlc_object_detach( p_help_module );
535         config_Free( p_help_module );
536         vlc_object_destroy( p_help_module );
537         module_EndBank( p_vlc );
538         if( i_object ) vlc_object_release( p_vlc );
539         return VLC_EGENERIC;
540     }
541
542     /* Hack: remove the help module here */
543     vlc_object_detach( p_help_module );
544     config_Free( p_help_module );
545     vlc_object_destroy( p_help_module );
546     /* End hack */
547
548     /*
549      * System specific configuration
550      */
551     system_Configure( p_vlc, &i_argc, ppsz_argv );
552
553     /*
554      * Message queue options
555      */
556
557     var_Create( p_vlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
558     if( config_GetInt( p_vlc, "quiet" ) )
559     {
560         vlc_value_t val;
561         val.i_int = -1;
562         var_Set( p_vlc, "verbose", val );
563     }
564     var_AddCallback( p_vlc, "verbose", VerboseCallback, NULL );
565     var_Change( p_vlc, "verbose", VLC_VAR_TRIGGER_CALLBACKS, NULL, NULL );
566
567     libvlc.b_color = libvlc.b_color && config_GetInt( p_vlc, "color" );
568
569     /*
570      * Output messages that may still be in the queue
571      */
572     msg_Flush( p_vlc );
573
574     /* p_vlc initialization. FIXME ? */
575
576 #if defined( __i386__ )
577     if( !config_GetInt( p_vlc, "mmx" ) )
578         libvlc.i_cpu &= ~CPU_CAPABILITY_MMX;
579     if( !config_GetInt( p_vlc, "3dn" ) )
580         libvlc.i_cpu &= ~CPU_CAPABILITY_3DNOW;
581     if( !config_GetInt( p_vlc, "mmxext" ) )
582         libvlc.i_cpu &= ~CPU_CAPABILITY_MMXEXT;
583     if( !config_GetInt( p_vlc, "sse" ) )
584         libvlc.i_cpu &= ~CPU_CAPABILITY_SSE;
585     if( !config_GetInt( p_vlc, "sse2" ) )
586         libvlc.i_cpu &= ~CPU_CAPABILITY_SSE2;
587 #endif
588 #if defined( __powerpc__ ) || defined( SYS_DARWIN )
589     if( !config_GetInt( p_vlc, "altivec" ) )
590         libvlc.i_cpu &= ~CPU_CAPABILITY_ALTIVEC;
591 #endif
592
593 #define PRINT_CAPABILITY( capability, string )                              \
594     if( libvlc.i_cpu & capability )                                         \
595     {                                                                       \
596         strncat( p_capabilities, string " ",                                \
597                  sizeof(p_capabilities) - strlen(p_capabilities) );         \
598         p_capabilities[sizeof(p_capabilities) - 1] = '\0';                  \
599     }
600
601     p_capabilities[0] = '\0';
602     PRINT_CAPABILITY( CPU_CAPABILITY_486, "486" );
603     PRINT_CAPABILITY( CPU_CAPABILITY_586, "586" );
604     PRINT_CAPABILITY( CPU_CAPABILITY_PPRO, "Pentium Pro" );
605     PRINT_CAPABILITY( CPU_CAPABILITY_MMX, "MMX" );
606     PRINT_CAPABILITY( CPU_CAPABILITY_3DNOW, "3DNow!" );
607     PRINT_CAPABILITY( CPU_CAPABILITY_MMXEXT, "MMXEXT" );
608     PRINT_CAPABILITY( CPU_CAPABILITY_SSE, "SSE" );
609     PRINT_CAPABILITY( CPU_CAPABILITY_SSE2, "SSE2" );
610     PRINT_CAPABILITY( CPU_CAPABILITY_ALTIVEC, "AltiVec" );
611     PRINT_CAPABILITY( CPU_CAPABILITY_FPU, "FPU" );
612     msg_Dbg( p_vlc, "CPU has capabilities %s", p_capabilities );
613
614     /*
615      * Choose the best memcpy module
616      */
617     p_vlc->p_memcpy_module = module_Need( p_vlc, "memcpy", "$memcpy", 0 );
618
619     if( p_vlc->pf_memcpy == NULL )
620     {
621         p_vlc->pf_memcpy = memcpy;
622     }
623
624     if( p_vlc->pf_memset == NULL )
625     {
626         p_vlc->pf_memset = memset;
627     }
628
629     /*
630      * Initialize hotkey handling
631      */
632     var_Create( p_vlc, "key-pressed", VLC_VAR_INTEGER );
633     p_vlc->p_hotkeys = malloc( sizeof(p_hotkeys) );
634     /* Do a copy (we don't need to modify the strings) */
635     memcpy( p_vlc->p_hotkeys, p_hotkeys, sizeof(p_hotkeys) );
636
637     /*
638      * Initialize playlist and get commandline files
639      */
640     p_playlist = playlist_Create( p_vlc );
641     if( !p_playlist )
642     {
643         msg_Err( p_vlc, "playlist initialization failed" );
644         if( p_vlc->p_memcpy_module != NULL )
645         {
646             module_Unneed( p_vlc, p_vlc->p_memcpy_module );
647         }
648         module_EndBank( p_vlc );
649         if( i_object ) vlc_object_release( p_vlc );
650         return VLC_EGENERIC;
651     }
652
653     psz_modules = config_GetPsz( p_playlist, "services-discovery" );
654     if( psz_modules && *psz_modules )
655     {
656         /* Add service discovery modules */
657         playlist_AddSDModules( p_playlist, psz_modules );
658     }
659     if( psz_modules ) free( psz_modules );
660
661     /*
662      * Load background interfaces
663      */
664     psz_modules = config_GetPsz( p_vlc, "extraintf" );
665     psz_control = config_GetPsz( p_vlc, "control" );
666
667     if( psz_modules && *psz_modules && psz_control && *psz_control )
668     {
669         psz_modules = (char *)realloc( psz_modules, strlen( psz_modules ) +
670                                                     strlen( psz_control ) + 1 );
671         sprintf( psz_modules, "%s,%s", psz_modules, psz_control );
672     }
673     else if( psz_control && *psz_control )
674     {
675         if( psz_modules ) free( psz_modules );
676         psz_modules = strdup( psz_control );
677     }
678
679     psz_parser = psz_modules;
680     while ( psz_parser && *psz_parser )
681     {
682         char *psz_module, *psz_temp;
683         psz_module = psz_parser;
684         psz_parser = strchr( psz_module, ',' );
685         if ( psz_parser )
686         {
687             *psz_parser = '\0';
688             psz_parser++;
689         }
690         psz_temp = (char *)malloc( strlen(psz_module) + sizeof(",none") );
691         if( psz_temp )
692         {
693             sprintf( psz_temp, "%s,none", psz_module );
694             VLC_AddIntf( 0, psz_temp, VLC_FALSE, VLC_FALSE );
695             free( psz_temp );
696         }
697     }
698     if ( psz_modules )
699     {
700         free( psz_modules );
701     }
702
703     /*
704      * Allways load the hotkeys interface if it exists
705      */
706     VLC_AddIntf( 0, "hotkeys,none", VLC_FALSE, VLC_FALSE );
707
708     /*
709      * FIXME: kludge to use a p_vlc-local variable for the Mozilla plugin
710      */
711     var_Create( p_vlc, "drawable", VLC_VAR_INTEGER );
712     var_Create( p_vlc, "drawableredraw", VLC_VAR_INTEGER );
713     var_Create( p_vlc, "drawablet", VLC_VAR_INTEGER );
714     var_Create( p_vlc, "drawablel", VLC_VAR_INTEGER );
715     var_Create( p_vlc, "drawableb", VLC_VAR_INTEGER );
716     var_Create( p_vlc, "drawabler", VLC_VAR_INTEGER );
717     var_Create( p_vlc, "drawablex", VLC_VAR_INTEGER );
718     var_Create( p_vlc, "drawabley", VLC_VAR_INTEGER );
719     var_Create( p_vlc, "drawablew", VLC_VAR_INTEGER );
720     var_Create( p_vlc, "drawableh", VLC_VAR_INTEGER );
721     var_Create( p_vlc, "drawableportx", VLC_VAR_INTEGER );
722     var_Create( p_vlc, "drawableporty", VLC_VAR_INTEGER );
723
724     /*
725      * Get input filenames given as commandline arguments
726      */
727     GetFilenames( p_vlc, i_argc, ppsz_argv );
728
729     if( i_object ) vlc_object_release( p_vlc );
730     return VLC_SUCCESS;
731 }
732
733 /*****************************************************************************
734  * VLC_AddIntf: add an interface
735  *****************************************************************************
736  * This function opens an interface plugin and runs it. If b_block is set
737  * to 0, VLC_AddIntf will return immediately and let the interface run in a
738  * separate thread. If b_block is set to 1, VLC_AddIntf will continue until
739  * user requests to quit. If b_play is set to 1, VLC_AddIntf will start playing
740  * the playlist when it is completely initialised.
741  *****************************************************************************/
742 int VLC_AddIntf( int i_object, char const *psz_module,
743                  vlc_bool_t b_block, vlc_bool_t b_play )
744 {
745     int i_err;
746     intf_thread_t *p_intf;
747     vlc_t *p_vlc = vlc_current_object( i_object );
748
749     if( !p_vlc )
750     {
751         return VLC_ENOOBJ;
752     }
753
754 #ifndef WIN32
755     if( p_vlc->p_libvlc->b_daemon && b_block && !psz_module )
756     {
757         /* Daemon mode hack.
758          * We prefer the dummy interface if none is specified. */
759         char *psz_interface = config_GetPsz( p_vlc, "intf" );
760         if( !psz_interface || !*psz_interface ) psz_module = "dummy";
761         if( psz_interface ) free( psz_interface );
762     }
763 #endif
764
765     /* Try to create the interface */
766     p_intf = intf_Create( p_vlc, psz_module ? psz_module : "$intf" );
767
768     if( p_intf == NULL )
769     {
770         msg_Err( p_vlc, "interface \"%s\" initialization failed", psz_module );
771         if( i_object ) vlc_object_release( p_vlc );
772         return VLC_EGENERIC;
773     }
774
775     /* Interface doesn't handle play on start so do it ourselves */
776     if( !p_intf->b_play && b_play ) VLC_Play( i_object );
777
778     /* Try to run the interface */
779     p_intf->b_play = b_play;
780     p_intf->b_block = b_block;
781     i_err = intf_RunThread( p_intf );
782     if( i_err )
783     {
784         vlc_object_detach( p_intf );
785         intf_Destroy( p_intf );
786         if( i_object ) vlc_object_release( p_vlc );
787         return i_err;
788     }
789
790     if( i_object ) vlc_object_release( p_vlc );
791     return VLC_SUCCESS;
792 }
793
794 /*****************************************************************************
795  * VLC_Die: ask vlc to die.
796  *****************************************************************************
797  * This function sets p_vlc->b_die to VLC_TRUE, but does not do any other
798  * task. It is your duty to call VLC_CleanUp and VLC_Destroy afterwards.
799  *****************************************************************************/
800 int VLC_Die( int i_object )
801 {
802     vlc_t *p_vlc = vlc_current_object( i_object );
803
804     if( !p_vlc )
805     {
806         return VLC_ENOOBJ;
807     }
808
809     p_vlc->b_die = VLC_TRUE;
810
811     if( i_object ) vlc_object_release( p_vlc );
812     return VLC_SUCCESS;
813 }
814
815 /*****************************************************************************
816  * VLC_CleanUp: CleanUp all the intf, playlist, vout, aout
817  *****************************************************************************/
818 int VLC_CleanUp( int i_object )
819 {
820     intf_thread_t      * p_intf;
821     playlist_t         * p_playlist;
822     vout_thread_t      * p_vout;
823     aout_instance_t    * p_aout;
824     announce_handler_t * p_announce;
825     vlc_t *p_vlc = vlc_current_object( i_object );
826
827     /* Check that the handle is valid */
828     if( !p_vlc )
829     {
830         return VLC_ENOOBJ;
831     }
832
833     /*
834      * Ask the interfaces to stop and destroy them
835      */
836     msg_Dbg( p_vlc, "removing all interfaces" );
837     while( (p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_CHILD )) )
838     {
839         intf_StopThread( p_intf );
840         vlc_object_detach( p_intf );
841         vlc_object_release( p_intf );
842         intf_Destroy( p_intf );
843     }
844
845     /*
846      * Free playlists
847      */
848     msg_Dbg( p_vlc, "removing all playlists" );
849     while( (p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST,
850                                           FIND_CHILD )) )
851     {
852         vlc_object_detach( p_playlist );
853         vlc_object_release( p_playlist );
854         playlist_Destroy( p_playlist );
855     }
856
857     /*
858      * Free video outputs
859      */
860     msg_Dbg( p_vlc, "removing all video outputs" );
861     while( (p_vout = vlc_object_find( p_vlc, VLC_OBJECT_VOUT, FIND_CHILD )) )
862     {
863         vlc_object_detach( p_vout );
864         vlc_object_release( p_vout );
865         vout_Destroy( p_vout );
866     }
867
868     /*
869      * Free audio outputs
870      */
871     msg_Dbg( p_vlc, "removing all audio outputs" );
872     while( (p_aout = vlc_object_find( p_vlc, VLC_OBJECT_AOUT, FIND_CHILD )) )
873     {
874         vlc_object_detach( (vlc_object_t *)p_aout );
875         vlc_object_release( (vlc_object_t *)p_aout );
876         aout_Delete( p_aout );
877     }
878
879     /*
880      * Free announce handler(s?)
881      */
882     msg_Dbg( p_vlc, "removing announce handler" );
883     while( (p_announce = vlc_object_find( p_vlc, VLC_OBJECT_ANNOUNCE,
884                                                  FIND_CHILD ) ) )
885    {
886         vlc_object_detach( p_announce );
887         vlc_object_release( p_announce );
888         announce_HandlerDestroy( p_announce );
889    }
890
891     if( i_object ) vlc_object_release( p_vlc );
892     return VLC_SUCCESS;
893 }
894
895 /*****************************************************************************
896  * VLC_Destroy: Destroy everything.
897  *****************************************************************************
898  * This function requests the running threads to finish, waits for their
899  * termination, and destroys their structure.
900  *****************************************************************************/
901 int VLC_Destroy( int i_object )
902 {
903     vlc_t *p_vlc = vlc_current_object( i_object );
904
905     if( !p_vlc )
906     {
907         return VLC_ENOOBJ;
908     }
909
910     /*
911      * Free allocated memory
912      */
913     if( p_vlc->p_memcpy_module )
914     {
915         module_Unneed( p_vlc, p_vlc->p_memcpy_module );
916         p_vlc->p_memcpy_module = NULL;
917     }
918
919     /*
920      * Free module bank !
921      */
922     module_EndBank( p_vlc );
923
924     if( p_vlc->psz_homedir )
925     {
926         free( p_vlc->psz_homedir );
927         p_vlc->psz_homedir = NULL;
928     }
929
930     if( p_vlc->psz_configfile )
931     {
932         free( p_vlc->psz_configfile );
933         p_vlc->psz_configfile = NULL;
934     }
935
936     if( p_vlc->p_hotkeys )
937     {
938         free( p_vlc->p_hotkeys );
939         p_vlc->p_hotkeys = NULL;
940     }
941
942     /*
943      * System specific cleaning code
944      */
945     system_End( p_vlc );
946
947     /* Destroy mutexes */
948     vlc_mutex_destroy( &p_vlc->config_lock );
949
950     vlc_object_detach( p_vlc );
951
952     /* Release object before destroying it */
953     if( i_object ) vlc_object_release( p_vlc );
954
955     vlc_object_destroy( p_vlc );
956
957     /* Stop thread system: last one out please shut the door! */
958     vlc_threads_end( p_libvlc );
959
960     return VLC_SUCCESS;
961 }
962
963 /*****************************************************************************
964  * VLC_VariableSet: set a vlc variable
965  *****************************************************************************/
966 int VLC_VariableSet( int i_object, char const *psz_var, vlc_value_t value )
967 {
968     vlc_t *p_vlc = vlc_current_object( i_object );
969     int i_ret;
970
971     if( !p_vlc )
972     {
973         return VLC_ENOOBJ;
974     }
975
976     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
977      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
978     if( !strncmp( psz_var, "conf::", 6 ) )
979     {
980         module_config_t *p_item;
981         char const *psz_newvar = psz_var + 6;
982
983         p_item = config_FindConfig( VLC_OBJECT(p_vlc), psz_newvar );
984
985         if( p_item )
986         {
987             switch( p_item->i_type )
988             {
989                 case CONFIG_ITEM_BOOL:
990                     config_PutInt( p_vlc, psz_newvar, value.b_bool );
991                     break;
992                 case CONFIG_ITEM_INTEGER:
993                     config_PutInt( p_vlc, psz_newvar, value.i_int );
994                     break;
995                 case CONFIG_ITEM_FLOAT:
996                     config_PutFloat( p_vlc, psz_newvar, value.f_float );
997                     break;
998                 default:
999                     config_PutPsz( p_vlc, psz_newvar, value.psz_string );
1000                     break;
1001             }
1002             if( i_object ) vlc_object_release( p_vlc );
1003             return VLC_SUCCESS;
1004         }
1005     }
1006
1007     i_ret = var_Set( p_vlc, psz_var, value );
1008
1009     if( i_object ) vlc_object_release( p_vlc );
1010     return i_ret;
1011 }
1012
1013 /*****************************************************************************
1014  * VLC_VariableGet: get a vlc variable
1015  *****************************************************************************/
1016 int VLC_VariableGet( int i_object, char const *psz_var, vlc_value_t *p_value )
1017 {
1018     vlc_t *p_vlc = vlc_current_object( i_object );
1019     int i_ret;
1020
1021     if( !p_vlc )
1022     {
1023         return VLC_ENOOBJ;
1024     }
1025
1026     i_ret = var_Get( p_vlc , psz_var, p_value );
1027
1028     if( i_object ) vlc_object_release( p_vlc );
1029     return i_ret;
1030 }
1031
1032 /*****************************************************************************
1033  * VLC_AddTarget: adds a target for playing.
1034  *****************************************************************************
1035  * This function adds psz_target to the current playlist. If a playlist does
1036  * not exist, it will create one.
1037  *****************************************************************************/
1038 int VLC_AddTarget( int i_object, char const *psz_target,
1039                    char const **ppsz_options, int i_options,
1040                    int i_mode, int i_pos )
1041 {
1042     int i_err;
1043     playlist_t *p_playlist;
1044     vlc_t *p_vlc = vlc_current_object( i_object );
1045
1046     if( !p_vlc )
1047     {
1048         return VLC_ENOOBJ;
1049     }
1050
1051     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1052
1053     if( p_playlist == NULL )
1054     {
1055         msg_Dbg( p_vlc, "no playlist present, creating one" );
1056         p_playlist = playlist_Create( p_vlc );
1057
1058         if( p_playlist == NULL )
1059         {
1060             if( i_object ) vlc_object_release( p_vlc );
1061             return VLC_EGENERIC;
1062         }
1063
1064         vlc_object_yield( p_playlist );
1065     }
1066
1067     i_err = playlist_AddExt( p_playlist, psz_target, psz_target,
1068                              i_mode, i_pos, -1, ppsz_options, i_options);
1069
1070     vlc_object_release( p_playlist );
1071
1072     if( i_object ) vlc_object_release( p_vlc );
1073     return i_err;
1074 }
1075
1076 /*****************************************************************************
1077  * VLC_Play: play
1078  *****************************************************************************/
1079 int VLC_Play( int i_object )
1080 {
1081     playlist_t * p_playlist;
1082     vlc_t *p_vlc = vlc_current_object( i_object );
1083
1084     /* Check that the handle is valid */
1085     if( !p_vlc )
1086     {
1087         return VLC_ENOOBJ;
1088     }
1089
1090     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1091
1092     if( !p_playlist )
1093     {
1094         if( i_object ) vlc_object_release( p_vlc );
1095         return VLC_ENOOBJ;
1096     }
1097
1098     playlist_Play( p_playlist );
1099     vlc_object_release( p_playlist );
1100
1101     if( i_object ) vlc_object_release( p_vlc );
1102     return VLC_SUCCESS;
1103 }
1104
1105 /*****************************************************************************
1106  * VLC_Pause: toggle pause
1107  *****************************************************************************/
1108 int VLC_Pause( int i_object )
1109 {
1110     playlist_t * p_playlist;
1111     vlc_t *p_vlc = vlc_current_object( i_object );
1112
1113     /* Check that the handle is valid */
1114     if( !p_vlc )
1115     {
1116         return VLC_ENOOBJ;
1117     }
1118
1119     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1120
1121     if( !p_playlist )
1122     {
1123         if( i_object ) vlc_object_release( p_vlc );
1124         return VLC_ENOOBJ;
1125     }
1126
1127     playlist_Pause( p_playlist );
1128     vlc_object_release( p_playlist );
1129
1130     if( i_object ) vlc_object_release( p_vlc );
1131     return VLC_SUCCESS;
1132 }
1133
1134 /*****************************************************************************
1135  * VLC_Pause: toggle pause
1136  *****************************************************************************/
1137 int VLC_Stop( int i_object )
1138 {
1139     playlist_t * p_playlist;
1140     vlc_t *p_vlc = vlc_current_object( i_object );
1141
1142     /* Check that the handle is valid */
1143     if( !p_vlc )
1144     {
1145         return VLC_ENOOBJ;
1146     }
1147
1148     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1149
1150     if( !p_playlist )
1151     {
1152         if( i_object ) vlc_object_release( p_vlc );
1153         return VLC_ENOOBJ;
1154     }
1155
1156     playlist_Stop( p_playlist );
1157     vlc_object_release( p_playlist );
1158
1159     if( i_object ) vlc_object_release( p_vlc );
1160     return VLC_SUCCESS;
1161 }
1162
1163 /*****************************************************************************
1164  * VLC_IsPlaying: Query for Playlist Status
1165  *****************************************************************************/
1166 vlc_bool_t VLC_IsPlaying( int i_object )
1167 {
1168     playlist_t * p_playlist;
1169     vlc_bool_t   b_playing;
1170
1171     vlc_t *p_vlc = vlc_current_object( i_object );
1172
1173     /* Check that the handle is valid */
1174     if( !p_vlc )
1175     {
1176         return VLC_ENOOBJ;
1177     }
1178
1179     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1180
1181     if( !p_playlist )
1182     {
1183         if( i_object ) vlc_object_release( p_vlc );
1184         return VLC_ENOOBJ;
1185     }
1186
1187     b_playing = playlist_IsPlaying( p_playlist );
1188     vlc_object_release( p_playlist );
1189
1190     if( i_object ) vlc_object_release( p_vlc );
1191     return b_playing;
1192 }
1193
1194 /**
1195  * Get the current position in a input
1196  *
1197  * Return the current position as a float
1198  * \note For some inputs, this will be unknown.
1199  *
1200  * \param i_object a vlc object id
1201  * \return a float in the range of 0.0 - 1.0
1202  */
1203 float VLC_PositionGet( int i_object )
1204 {
1205     input_thread_t *p_input;
1206     vlc_value_t val;
1207     vlc_t *p_vlc = vlc_current_object( i_object );
1208
1209     /* Check that the handle is valid */
1210     if( !p_vlc )
1211     {
1212         return VLC_ENOOBJ;
1213     }
1214
1215     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1216
1217     if( !p_input )
1218     {
1219         if( i_object ) vlc_object_release( p_vlc );
1220         return VLC_ENOOBJ;
1221     }
1222
1223     var_Get( p_input, "position", &val );
1224     vlc_object_release( p_input );
1225
1226     if( i_object ) vlc_object_release( p_vlc );
1227     return val.f_float;
1228 }
1229
1230 /**
1231  * Set the current position in a input
1232  *
1233  * Set the current position in a input and then return
1234  * the current position as a float.
1235  * \note For some inputs, this will be unknown.
1236  *
1237  * \param i_object a vlc object id
1238  * \param i_position a float in the range of 0.0 - 1.0
1239  * \return a float in the range of 0.0 - 1.0
1240  */
1241 float VLC_PositionSet( int i_object, float i_position )
1242 {
1243     input_thread_t *p_input;
1244     vlc_value_t val;
1245     vlc_t *p_vlc = vlc_current_object( i_object );
1246
1247     /* Check that the handle is valid */
1248     if( !p_vlc )
1249     {
1250         return VLC_ENOOBJ;
1251     }
1252
1253     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1254
1255     if( !p_input )
1256     {
1257         if( i_object ) vlc_object_release( p_vlc );
1258         return VLC_ENOOBJ;
1259     }
1260
1261     val.f_float = i_position;
1262     var_Set( p_input, "position", val );
1263     var_Get( p_input, "position", &val );
1264     vlc_object_release( p_input );
1265
1266     if( i_object ) vlc_object_release( p_vlc );
1267     return val.f_float;
1268 }
1269
1270 /**
1271  * Get the current position in a input
1272  *
1273  * Return the current position in seconds from the start.
1274  * \note For some inputs, this will be unknown.
1275  *
1276  * \param i_object a vlc object id
1277  * \return the offset from 0:00 in seconds
1278  */
1279 int VLC_TimeGet( int i_object )
1280 {
1281     input_thread_t *p_input;
1282     vlc_value_t val;
1283     vlc_t *p_vlc = vlc_current_object( i_object );
1284
1285     /* Check that the handle is valid */
1286     if( !p_vlc )
1287     {
1288         return VLC_ENOOBJ;
1289     }
1290
1291     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1292
1293     if( !p_input )
1294     {
1295         if( i_object ) vlc_object_release( p_vlc );
1296         return VLC_ENOOBJ;
1297     }
1298
1299     var_Get( p_input, "time", &val );
1300     vlc_object_release( p_input );
1301
1302     if( i_object ) vlc_object_release( p_vlc );
1303     return val.i_time  / 1000000;
1304 }
1305
1306 /**
1307  * Seek to a position in the current input
1308  *
1309  * Seek i_seconds in the current input. If b_relative is set,
1310  * then the seek will be relative to the current position, otherwise
1311  * it will seek to i_seconds from the beginning of the input.
1312  * \note For some inputs, this will be unknown.
1313  *
1314  * \param i_object a vlc object id
1315  * \param i_seconds seconds from current position or from beginning of input
1316  * \param b_relative seek relative from current position
1317  * \return VLC_SUCCESS on success
1318  */
1319 int VLC_TimeSet( int i_object, int i_seconds, vlc_bool_t b_relative )
1320 {
1321     input_thread_t *p_input;
1322     vlc_value_t val;
1323     vlc_t *p_vlc = vlc_current_object( i_object );
1324
1325     /* Check that the handle is valid */
1326     if( !p_vlc )
1327     {
1328         return VLC_ENOOBJ;
1329     }
1330
1331     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1332
1333     if( !p_input )
1334     {
1335         if( i_object ) vlc_object_release( p_vlc );
1336         return VLC_ENOOBJ;
1337     }
1338
1339     if( b_relative )
1340     {
1341         val.i_time = i_seconds * 1000000;
1342         var_Set( p_input, "time-offset", val );
1343     }
1344     else
1345     {
1346         val.i_time = i_seconds * 1000000;
1347         var_Set( p_input, "time", val );
1348     }
1349     vlc_object_release( p_input );
1350
1351     if( i_object ) vlc_object_release( p_vlc );
1352     return VLC_SUCCESS;
1353 }
1354
1355 /**
1356  * Get the total length of a input
1357  *
1358  * Return the total length in seconds from the current input.
1359  * \note For some inputs, this will be unknown.
1360  *
1361  * \param i_object a vlc object id
1362  * \return the length in seconds
1363  */
1364 int VLC_LengthGet( int i_object )
1365 {
1366     input_thread_t *p_input;
1367     vlc_value_t val;
1368     vlc_t *p_vlc = vlc_current_object( i_object );
1369
1370     /* Check that the handle is valid */
1371     if( !p_vlc )
1372     {
1373         return VLC_ENOOBJ;
1374     }
1375
1376     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1377
1378     if( !p_input )
1379     {
1380         if( i_object ) vlc_object_release( p_vlc );
1381         return VLC_ENOOBJ;
1382     }
1383
1384     var_Get( p_input, "length", &val );
1385     vlc_object_release( p_input );
1386
1387     if( i_object ) vlc_object_release( p_vlc );
1388     return val.i_time  / 1000000;
1389 }
1390
1391 /**
1392  * Play the input faster than realtime
1393  *
1394  * 2x, 4x, 8x faster than realtime
1395  * \note For some inputs, this will be impossible.
1396  *
1397  * \param i_object a vlc object id
1398  * \return the current speedrate
1399  */
1400 float VLC_SpeedFaster( int i_object )
1401 {
1402     input_thread_t *p_input;
1403     vlc_value_t val;
1404     vlc_t *p_vlc = vlc_current_object( i_object );
1405
1406     /* Check that the handle is valid */
1407     if( !p_vlc )
1408     {
1409         return VLC_ENOOBJ;
1410     }
1411
1412     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1413
1414     if( !p_input )
1415     {
1416         if( i_object ) vlc_object_release( p_vlc );
1417         return VLC_ENOOBJ;
1418     }
1419
1420     val.b_bool = VLC_TRUE;
1421     var_Set( p_input, "rate-faster", val );
1422     var_Get( p_input, "rate", &val );
1423     vlc_object_release( p_input );
1424
1425     if( i_object ) vlc_object_release( p_vlc );
1426     return val.f_float / INPUT_RATE_DEFAULT;
1427 }
1428
1429 /**
1430  * Play the input slower than realtime
1431  *
1432  * 1/2x, 1/4x, 1/8x slower than realtime
1433  * \note For some inputs, this will be impossible.
1434  *
1435  * \param i_object a vlc object id
1436  * \return the current speedrate
1437  */
1438 float VLC_SpeedSlower( int i_object )
1439 {
1440     input_thread_t *p_input;
1441     vlc_value_t val;
1442     vlc_t *p_vlc = vlc_current_object( i_object );
1443
1444     /* Check that the handle is valid */
1445     if( !p_vlc )
1446     {
1447         return VLC_ENOOBJ;
1448     }
1449
1450     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1451
1452     if( !p_input )
1453     {
1454         if( i_object ) vlc_object_release( p_vlc );
1455         return VLC_ENOOBJ;
1456     }
1457
1458     val.b_bool = VLC_TRUE;
1459     var_Set( p_input, "rate-slower", val );
1460     var_Get( p_input, "rate", &val );
1461     vlc_object_release( p_input );
1462
1463     if( i_object ) vlc_object_release( p_vlc );
1464     return val.f_float / INPUT_RATE_DEFAULT;
1465 }
1466
1467 /**
1468  * Return the current playlist item
1469  *
1470  * Returns the index of the playlistitem that is currently selected for play.
1471  * This is valid even if nothing is currently playing.
1472  *
1473  * \param i_object a vlc object id
1474  * \return the current index
1475  */
1476 int VLC_PlaylistIndex( int i_object )
1477 {
1478     int i_index;
1479     playlist_t * p_playlist;
1480     vlc_t *p_vlc = vlc_current_object( i_object );
1481
1482     /* Check that the handle is valid */
1483     if( !p_vlc )
1484     {
1485         return VLC_ENOOBJ;
1486     }
1487
1488     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1489
1490     if( !p_playlist )
1491     {
1492         if( i_object ) vlc_object_release( p_vlc );
1493         return VLC_ENOOBJ;
1494     }
1495
1496     i_index = p_playlist->i_index;
1497     vlc_object_release( p_playlist );
1498
1499     if( i_object ) vlc_object_release( p_vlc );
1500     return i_index;
1501 }
1502
1503 /**
1504  * Total amount of items in the playlist
1505  *
1506  * \param i_object a vlc object id
1507  * \return amount of playlist items
1508  */
1509 int VLC_PlaylistNumberOfItems( int i_object )
1510 {
1511     int i_size;
1512     playlist_t * p_playlist;
1513     vlc_t *p_vlc = vlc_current_object( i_object );
1514
1515     /* Check that the handle is valid */
1516     if( !p_vlc )
1517     {
1518         return VLC_ENOOBJ;
1519     }
1520
1521     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1522
1523     if( !p_playlist )
1524     {
1525         if( i_object ) vlc_object_release( p_vlc );
1526         return VLC_ENOOBJ;
1527     }
1528
1529     i_size = p_playlist->i_size;
1530     vlc_object_release( p_playlist );
1531
1532     if( i_object ) vlc_object_release( p_vlc );
1533     return i_size;
1534 }
1535
1536 /**
1537  * Next playlist item
1538  *
1539  * Skip to the next playlistitem and play it.
1540  *
1541  * \param i_object a vlc object id
1542  * \return VLC_SUCCESS on success
1543  */
1544 int VLC_PlaylistNext( int i_object )
1545 {
1546     playlist_t * p_playlist;
1547     vlc_t *p_vlc = vlc_current_object( i_object );
1548
1549     /* Check that the handle is valid */
1550     if( !p_vlc )
1551     {
1552         return VLC_ENOOBJ;
1553     }
1554
1555     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1556
1557     if( !p_playlist )
1558     {
1559         if( i_object ) vlc_object_release( p_vlc );
1560         return VLC_ENOOBJ;
1561     }
1562
1563     playlist_Next( p_playlist );
1564     vlc_object_release( p_playlist );
1565
1566     if( i_object ) vlc_object_release( p_vlc );
1567     return VLC_SUCCESS;
1568 }
1569
1570 /**
1571  * Previous playlist item
1572  *
1573  * Skip to the previous playlistitem and play it.
1574  *
1575  * \param i_object a vlc object id
1576  * \return VLC_SUCCESS on success
1577  */
1578 int VLC_PlaylistPrev( int i_object )
1579 {
1580     playlist_t * p_playlist;
1581     vlc_t *p_vlc = vlc_current_object( i_object );
1582
1583     /* Check that the handle is valid */
1584     if( !p_vlc )
1585     {
1586         return VLC_ENOOBJ;
1587     }
1588
1589     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1590
1591     if( !p_playlist )
1592     {
1593         if( i_object ) vlc_object_release( p_vlc );
1594         return VLC_ENOOBJ;
1595     }
1596
1597     playlist_Prev( p_playlist );
1598     vlc_object_release( p_playlist );
1599
1600     if( i_object ) vlc_object_release( p_vlc );
1601     return VLC_SUCCESS;
1602 }
1603
1604
1605 /*****************************************************************************
1606  * VLC_PlaylistClear: Empty the playlist
1607  *****************************************************************************/
1608 int VLC_PlaylistClear( int i_object )
1609 {
1610     int i_err;
1611     playlist_t * p_playlist;
1612     vlc_t *p_vlc = vlc_current_object( i_object );
1613
1614     /* Check that the handle is valid */
1615     if( !p_vlc )
1616     {
1617         return VLC_ENOOBJ;
1618     }
1619
1620     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1621
1622     if( !p_playlist )
1623     {
1624         if( i_object ) vlc_object_release( p_vlc );
1625         return VLC_ENOOBJ;
1626     }
1627
1628     i_err = playlist_Clear( p_playlist );
1629
1630     vlc_object_release( p_playlist );
1631
1632     if( i_object ) vlc_object_release( p_vlc );
1633     return i_err;
1634 }
1635
1636 /**
1637  * Change the volume
1638  *
1639  * \param i_object a vlc object id
1640  * \param i_volume something in a range from 0-200
1641  * \return the new volume (range 0-200 %)
1642  */
1643 int VLC_VolumeSet( int i_object, int i_volume )
1644 {
1645     audio_volume_t i_vol = 0;
1646     vlc_t *p_vlc = vlc_current_object( i_object );
1647
1648     /* Check that the handle is valid */
1649     if( !p_vlc )
1650     {
1651         return VLC_ENOOBJ;
1652     }
1653
1654     if( i_volume >= 0 && i_volume <= 200 )
1655     {
1656         i_vol = i_volume * AOUT_VOLUME_MAX / 200;
1657         aout_VolumeSet( p_vlc, i_vol );
1658     }
1659
1660     if( i_object ) vlc_object_release( p_vlc );
1661     return i_vol * 200 / AOUT_VOLUME_MAX;
1662 }
1663
1664 /**
1665  * Get the current volume
1666  *
1667  * Retrieve the current volume.
1668  *
1669  * \param i_object a vlc object id
1670  * \return the current volume (range 0-200 %)
1671  */
1672 int VLC_VolumeGet( int i_object )
1673 {
1674     audio_volume_t i_volume;
1675     vlc_t *p_vlc = vlc_current_object( i_object );
1676
1677     /* Check that the handle is valid */
1678     if( !p_vlc )
1679     {
1680         return VLC_ENOOBJ;
1681     }
1682
1683     aout_VolumeGet( p_vlc, &i_volume );
1684
1685     if( i_object ) vlc_object_release( p_vlc );
1686     return i_volume*200/AOUT_VOLUME_MAX;
1687 }
1688
1689 /**
1690  * Mute/Unmute the volume
1691  *
1692  * \param i_object a vlc object id
1693  * \return VLC_SUCCESS on success
1694  */
1695 int VLC_VolumeMute( int i_object )
1696 {
1697     vlc_t *p_vlc = vlc_current_object( i_object );
1698
1699     /* Check that the handle is valid */
1700     if( !p_vlc )
1701     {
1702         return VLC_ENOOBJ;
1703     }
1704
1705     aout_VolumeMute( p_vlc, NULL );
1706
1707     if( i_object ) vlc_object_release( p_vlc );
1708     return VLC_SUCCESS;
1709 }
1710
1711 /*****************************************************************************
1712  * VLC_FullScreen: toggle fullscreen mode
1713  *****************************************************************************/
1714 int VLC_FullScreen( int i_object )
1715 {
1716     vout_thread_t *p_vout;
1717     vlc_t *p_vlc = vlc_current_object( i_object );
1718
1719     if( !p_vlc )
1720     {
1721         return VLC_ENOOBJ;
1722     }
1723
1724     p_vout = vlc_object_find( p_vlc, VLC_OBJECT_VOUT, FIND_CHILD );
1725
1726     if( !p_vout )
1727     {
1728         if( i_object ) vlc_object_release( p_vlc );
1729         return VLC_ENOOBJ;
1730     }
1731
1732     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
1733     vlc_object_release( p_vout );
1734
1735     if( i_object ) vlc_object_release( p_vlc );
1736     return VLC_SUCCESS;
1737 }
1738
1739 /* following functions are local */
1740
1741 /*****************************************************************************
1742  * SetLanguage: set the interface language.
1743  *****************************************************************************
1744  * We set the LC_MESSAGES locale category for interface messages and buttons,
1745  * as well as the LC_CTYPE category for string sorting and possible wide
1746  * character support.
1747  *****************************************************************************/
1748 static void SetLanguage ( char const *psz_lang )
1749 {
1750 #if defined( ENABLE_NLS ) \
1751      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
1752
1753     char *          psz_path;
1754 #if defined( SYS_DARWIN ) || defined ( WIN32 ) || defined( SYS_BEOS )
1755     char            psz_tmp[1024];
1756 #endif
1757
1758     if( psz_lang && !*psz_lang )
1759     {
1760 #   if defined( HAVE_LC_MESSAGES )
1761         setlocale( LC_MESSAGES, psz_lang );
1762 #   endif
1763         setlocale( LC_CTYPE, psz_lang );
1764     }
1765     else if( psz_lang )
1766     {
1767 #ifdef SYS_DARWIN
1768         /* I need that under Darwin, please check it doesn't disturb
1769          * other platforms. --Meuuh */
1770         setenv( "LANG", psz_lang, 1 );
1771
1772 #elif defined( SYS_BEOS ) || defined( WIN32 )
1773         /* We set LC_ALL manually because it is the only way to set
1774          * the language at runtime under eg. Windows. Beware that this
1775          * makes the environment unconsistent when libvlc is unloaded and
1776          * should probably be moved to a safer place like vlc.c. */
1777         static char psz_lcall[20];
1778         snprintf( psz_lcall, 19, "LC_ALL=%s", psz_lang );
1779         psz_lcall[19] = '\0';
1780         putenv( psz_lcall );
1781 #endif
1782
1783         setlocale( LC_ALL, psz_lang );
1784     }
1785
1786     /* Specify where to find the locales for current domain */
1787 #if !defined( SYS_DARWIN ) && !defined( WIN32 ) && !defined( SYS_BEOS )
1788     psz_path = LOCALEDIR;
1789 #else
1790     snprintf( psz_tmp, sizeof(psz_tmp), "%s/%s", libvlc.psz_vlcpath,
1791               "locale" );
1792     psz_path = psz_tmp;
1793 #endif
1794     if( !bindtextdomain( PACKAGE_NAME, psz_path ) )
1795     {
1796         fprintf( stderr, "warning: no domain %s in directory %s\n",
1797                  PACKAGE_NAME, psz_path );
1798     }
1799
1800     /* Set the default domain */
1801     textdomain( PACKAGE_NAME );
1802
1803 #if defined( ENABLE_UTF8 )
1804     bind_textdomain_codeset( PACKAGE_NAME, "UTF-8" );
1805 #endif
1806
1807 #endif
1808 }
1809
1810 /*****************************************************************************
1811  * GetFilenames: parse command line options which are not flags
1812  *****************************************************************************
1813  * Parse command line for input files as well as their associated options.
1814  * An option always follows its associated input and begins with a ":".
1815  *****************************************************************************/
1816 static int GetFilenames( vlc_t *p_vlc, int i_argc, char *ppsz_argv[] )
1817 {
1818     int i_opt, i_options;
1819
1820     /* We assume that the remaining parameters are filenames
1821      * and their input options */
1822     for( i_opt = i_argc - 1; i_opt >= optind; i_opt-- )
1823     {
1824         i_options = 0;
1825
1826         /* Count the input options */
1827         while( *ppsz_argv[ i_opt ] == ':' && i_opt > optind )
1828         {
1829             i_options++;
1830             i_opt--;
1831         }
1832
1833         /* TODO: write an internal function of this one, to avoid
1834          *       unnecessary lookups. */
1835         VLC_AddTarget( p_vlc->i_object_id, ppsz_argv[ i_opt ],
1836                        (char const **)( i_options ? &ppsz_argv[i_opt + 1] :
1837                                         NULL ), i_options,
1838                        PLAYLIST_INSERT, 0 );
1839     }
1840
1841     return VLC_SUCCESS;
1842 }
1843
1844 /*****************************************************************************
1845  * Usage: print program usage
1846  *****************************************************************************
1847  * Print a short inline help. Message interface is initialized at this stage.
1848  *****************************************************************************/
1849 static void Usage( vlc_t *p_this, char const *psz_module_name )
1850 {
1851 #define FORMAT_STRING "  %s --%s%s%s%s%s%s%s "
1852     /* short option ------'    |     | | | |  | |
1853      * option name ------------'     | | | |  | |
1854      * <bra -------------------------' | | |  | |
1855      * option type or "" --------------' | |  | |
1856      * ket> -----------------------------' |  | |
1857      * padding spaces ---------------------'  | |
1858      * comment -------------------------------' |
1859      * comment suffix --------------------------'
1860      *
1861      * The purpose of having bra and ket is that we might i18n them as well.
1862      */
1863 #define LINE_START 8
1864 #define PADDING_SPACES 25
1865     vlc_list_t *p_list;
1866     module_t *p_parser;
1867     module_config_t *p_item;
1868     char psz_spaces_text[PADDING_SPACES+LINE_START+1];
1869     char psz_spaces_longtext[LINE_START+3];
1870     char psz_format[sizeof(FORMAT_STRING)];
1871     char psz_buffer[10000];
1872     char psz_short[4];
1873     int i_index;
1874     int i_width = ConsoleWidth() - (PADDING_SPACES+LINE_START+1);
1875     vlc_bool_t b_advanced = config_GetInt( p_this, "advanced" );
1876     vlc_bool_t b_description;
1877
1878     memset( psz_spaces_text, ' ', PADDING_SPACES+LINE_START );
1879     psz_spaces_text[PADDING_SPACES+LINE_START] = '\0';
1880     memset( psz_spaces_longtext, ' ', LINE_START+2 );
1881     psz_spaces_longtext[LINE_START+2] = '\0';
1882
1883     strcpy( psz_format, FORMAT_STRING );
1884
1885 #ifdef WIN32
1886     ShowConsole();
1887 #endif
1888
1889     /* List all modules */
1890     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1891
1892     /* Enumerate the config for each module */
1893     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1894     {
1895         vlc_bool_t b_help_module;
1896
1897         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1898
1899         if( psz_module_name && strcmp( psz_module_name,
1900                                        p_parser->psz_object_name ) )
1901         {
1902             continue;
1903         }
1904
1905         /* Ignore modules without config options */
1906         if( !p_parser->i_config_items )
1907         {
1908             continue;
1909         }
1910
1911         /* Ignore modules with only advanced config options if requested */
1912         if( !b_advanced )
1913         {
1914             for( p_item = p_parser->p_config;
1915                  p_item->i_type != CONFIG_HINT_END;
1916                  p_item++ )
1917             {
1918                 if( (p_item->i_type & CONFIG_ITEM) &&
1919                     !p_item->b_advanced ) break;
1920             }
1921             if( p_item->i_type == CONFIG_HINT_END ) continue;
1922         }
1923
1924         /* Print name of module */
1925         if( strcmp( "main", p_parser->psz_object_name ) )
1926         fprintf( stdout, "\n %s\n", p_parser->psz_longname );
1927
1928         b_help_module = !strcmp( "help", p_parser->psz_object_name );
1929
1930         /* Print module options */
1931         for( p_item = p_parser->p_config;
1932              p_item->i_type != CONFIG_HINT_END;
1933              p_item++ )
1934         {
1935             char *psz_text, *psz_spaces = psz_spaces_text;
1936             char *psz_bra = NULL, *psz_type = NULL, *psz_ket = NULL;
1937             char *psz_suf = "", *psz_prefix = NULL;
1938             int i;
1939
1940             /* Skip advanced options if requested */
1941             if( p_item->b_advanced && !b_advanced )
1942             {
1943                 continue;
1944             }
1945
1946             switch( p_item->i_type )
1947             {
1948             case CONFIG_HINT_CATEGORY:
1949             case CONFIG_HINT_USAGE:
1950                 if( !strcmp( "main", p_parser->psz_object_name ) )
1951                 fprintf( stdout, "\n %s\n", p_item->psz_text );
1952                 break;
1953
1954             case CONFIG_ITEM_STRING:
1955             case CONFIG_ITEM_FILE:
1956             case CONFIG_ITEM_DIRECTORY:
1957             case CONFIG_ITEM_MODULE: /* We could also have "=<" here */
1958             case CONFIG_ITEM_MODULE_CAT:
1959             case CONFIG_ITEM_MODULE_LIST:
1960             case CONFIG_ITEM_MODULE_LIST_CAT:
1961                 psz_bra = " <"; psz_type = _("string"); psz_ket = ">";
1962
1963                 if( p_item->ppsz_list )
1964                 {
1965                     psz_bra = " {";
1966                     psz_type = psz_buffer;
1967                     psz_type[0] = '\0';
1968                     for( i = 0; p_item->ppsz_list[i]; i++ )
1969                     {
1970                         if( i ) strcat( psz_type, "," );
1971                         strcat( psz_type, p_item->ppsz_list[i] );
1972                     }
1973                     psz_ket = "}";
1974                 }
1975                 break;
1976             case CONFIG_ITEM_INTEGER:
1977             case CONFIG_ITEM_KEY: /* FIXME: do something a bit more clever */
1978                 psz_bra = " <"; psz_type = _("integer"); psz_ket = ">";
1979
1980                 if( p_item->i_list )
1981                 {
1982                     psz_bra = " {";
1983                     psz_type = psz_buffer;
1984                     psz_type[0] = '\0';
1985                     for( i = 0; p_item->ppsz_list_text[i]; i++ )
1986                     {
1987                         if( i ) strcat( psz_type, ", " );
1988                         sprintf( psz_type + strlen(psz_type), "%i (%s)",
1989                                  p_item->pi_list[i],
1990                                  p_item->ppsz_list_text[i] );
1991                     }
1992                     psz_ket = "}";
1993                 }
1994                 break;
1995             case CONFIG_ITEM_FLOAT:
1996                 psz_bra = " <"; psz_type = _("float"); psz_ket = ">";
1997                 break;
1998             case CONFIG_ITEM_BOOL:
1999                 psz_bra = ""; psz_type = ""; psz_ket = "";
2000                 if( !b_help_module )
2001                 {
2002                     psz_suf = p_item->i_value ? _(" (default enabled)") :
2003                                                 _(" (default disabled)");
2004                 }
2005                 break;
2006             }
2007
2008             if( !psz_type )
2009             {
2010                 continue;
2011             }
2012
2013             /* Add short option if any */
2014             if( p_item->i_short )
2015             {
2016                 sprintf( psz_short, "-%c,", p_item->i_short );
2017             }
2018             else
2019             {
2020                 strcpy( psz_short, "   " );
2021             }
2022
2023             i = PADDING_SPACES - strlen( p_item->psz_name )
2024                  - strlen( psz_bra ) - strlen( psz_type )
2025                  - strlen( psz_ket ) - 1;
2026
2027             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
2028             {
2029                 /* If option is of type --foo-bar, we print its counterpart
2030                  * as --no-foo-bar, but if it is of type --foobar (without
2031                  * dashes in the name) we print it as --nofoobar. Both
2032                  * values are of course valid, only the display changes. */
2033                 psz_prefix = strchr( p_item->psz_name, '-' ) ? ", --no-"
2034                                                              : ", --no";
2035                 i -= strlen( p_item->psz_name ) + strlen( psz_prefix );
2036             }
2037
2038             if( i < 0 )
2039             {
2040                 psz_spaces[0] = '\n';
2041                 i = 0;
2042             }
2043             else
2044             {
2045                 psz_spaces[i] = '\0';
2046             }
2047
2048             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
2049             {
2050                 fprintf( stdout, psz_format, psz_short, p_item->psz_name,
2051                          psz_prefix, p_item->psz_name, psz_bra, psz_type,
2052                          psz_ket, psz_spaces );
2053             }
2054             else
2055             {
2056                 fprintf( stdout, psz_format, psz_short, p_item->psz_name,
2057                          "", "", psz_bra, psz_type, psz_ket, psz_spaces );
2058             }
2059
2060             psz_spaces[i] = ' ';
2061
2062             /* We wrap the rest of the output */
2063             sprintf( psz_buffer, "%s%s", p_item->psz_text, psz_suf );
2064             b_description = config_GetInt( p_this, "help-verbose" );
2065
2066  description:
2067             psz_text = psz_buffer;
2068             while( *psz_text )
2069             {
2070                 char *psz_parser, *psz_word;
2071                 int i_end = strlen( psz_text );
2072
2073                 /* If the remaining text fits in a line, print it. */
2074                 if( i_end <= i_width )
2075                 {
2076                     fprintf( stdout, "%s\n", psz_text );
2077                     break;
2078                 }
2079
2080                 /* Otherwise, eat as many words as possible */
2081                 psz_parser = psz_text;
2082                 do
2083                 {
2084                     psz_word = psz_parser;
2085                     psz_parser = strchr( psz_word, ' ' );
2086                     /* If no space was found, we reached the end of the text
2087                      * block; otherwise, we skip the space we just found. */
2088                     psz_parser = psz_parser ? psz_parser + 1
2089                                             : psz_text + i_end;
2090
2091                 } while( psz_parser - psz_text <= i_width );
2092
2093                 /* We cut a word in one of these cases:
2094                  *  - it's the only word in the line and it's too long.
2095                  *  - we used less than 80% of the width and the word we are
2096                  *    going to wrap is longer than 40% of the width, and even
2097                  *    if the word would have fit in the next line. */
2098                 if( psz_word == psz_text
2099                      || ( psz_word - psz_text < 80 * i_width / 100
2100                            && psz_parser - psz_word > 40 * i_width / 100 ) )
2101                 {
2102                     char c = psz_text[i_width];
2103                     psz_text[i_width] = '\0';
2104                     fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
2105                     psz_text += i_width;
2106                     psz_text[0] = c;
2107                 }
2108                 else
2109                 {
2110                     psz_word[-1] = '\0';
2111                     fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
2112                     psz_text = psz_word;
2113                 }
2114             }
2115
2116             if( b_description && p_item->psz_longtext )
2117             {
2118                 sprintf( psz_buffer, "%s%s", p_item->psz_longtext, psz_suf );
2119                 b_description = VLC_FALSE;
2120                 psz_spaces = psz_spaces_longtext;
2121                 fprintf( stdout, "%s", psz_spaces );
2122                 goto description;
2123             }
2124         }
2125     }
2126
2127     /* Release the module list */
2128     vlc_list_release( p_list );
2129
2130 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
2131     PauseConsole();
2132 #endif
2133 }
2134
2135 /*****************************************************************************
2136  * ListModules: list the available modules with their description
2137  *****************************************************************************
2138  * Print a list of all available modules (builtins and plugins) and a short
2139  * description for each one.
2140  *****************************************************************************/
2141 static void ListModules( vlc_t *p_this )
2142 {
2143     vlc_list_t *p_list;
2144     module_t *p_parser;
2145     char psz_spaces[22];
2146     int i_index;
2147
2148     memset( psz_spaces, ' ', 22 );
2149
2150 #ifdef WIN32
2151     ShowConsole();
2152 #endif
2153
2154     /* Usage */
2155     fprintf( stdout, _("Usage: %s [options] [items]...\n\n"),
2156                      p_this->p_vlc->psz_object_name );
2157
2158     fprintf( stdout, _("[module]              [description]\n") );
2159
2160     /* List all modules */
2161     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
2162
2163     /* Enumerate each module */
2164     for( i_index = 0; i_index < p_list->i_count; i_index++ )
2165     {
2166         int i;
2167
2168         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
2169
2170         /* Nasty hack, but right now I'm too tired to think about a nice
2171          * solution */
2172         i = 22 - strlen( p_parser->psz_object_name ) - 1;
2173         if( i < 0 ) i = 0;
2174         psz_spaces[i] = 0;
2175
2176         fprintf( stdout, "  %s%s %s\n", p_parser->psz_object_name,
2177                          psz_spaces, p_parser->psz_longname );
2178
2179         psz_spaces[i] = ' ';
2180     }
2181
2182     vlc_list_release( p_list );
2183
2184 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
2185     PauseConsole();
2186 #endif
2187 }
2188
2189 /*****************************************************************************
2190  * Version: print complete program version
2191  *****************************************************************************
2192  * Print complete program version and build number.
2193  *****************************************************************************/
2194 static void Version( void )
2195 {
2196 #ifdef WIN32
2197     ShowConsole();
2198 #endif
2199
2200     fprintf( stdout, VERSION_MESSAGE "\n" );
2201     fprintf( stdout,
2202       _("This program comes with NO WARRANTY, to the extent permitted by "
2203         "law.\nYou may redistribute it under the terms of the GNU General "
2204         "Public License;\nsee the file named COPYING for details.\n"
2205         "Written by the VideoLAN team; see the AUTHORS file.\n") );
2206
2207 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
2208     PauseConsole();
2209 #endif
2210 }
2211
2212 /*****************************************************************************
2213  * ShowConsole: On Win32, create an output console for debug messages
2214  *****************************************************************************
2215  * This function is useful only on Win32.
2216  *****************************************************************************/
2217 #ifdef WIN32 /*  */
2218 static void ShowConsole( void )
2219 {
2220 #   ifndef UNDER_CE
2221
2222     if( getenv( "PWD" ) && getenv( "PS1" ) ) return; /* cygwin shell */
2223
2224     AllocConsole();
2225     freopen( "CONOUT$", "w", stdout );
2226     freopen( "CONOUT$", "w", stderr );
2227     freopen( "CONIN$", "r", stdin );
2228
2229 #   endif
2230 }
2231 #endif
2232
2233 /*****************************************************************************
2234  * PauseConsole: On Win32, wait for a key press before closing the console
2235  *****************************************************************************
2236  * This function is useful only on Win32.
2237  *****************************************************************************/
2238 #ifdef WIN32 /*  */
2239 static void PauseConsole( void )
2240 {
2241 #   ifndef UNDER_CE
2242
2243     if( getenv( "PWD" ) && getenv( "PS1" ) ) return; /* cygwin shell */
2244     fprintf( stdout, _("\nPress the RETURN key to continue...\n") );
2245     getchar();
2246
2247 #   endif
2248 }
2249 #endif
2250
2251 /*****************************************************************************
2252  * ConsoleWidth: Return the console width in characters
2253  *****************************************************************************
2254  * We use the stty shell command to get the console width; if this fails or
2255  * if the width is less than 80, we default to 80.
2256  *****************************************************************************/
2257 static int ConsoleWidth( void )
2258 {
2259     int i_width = 80;
2260
2261 #ifndef WIN32
2262     char buf[20], *psz_parser;
2263     FILE *file;
2264     int i_ret;
2265
2266     file = popen( "stty size 2>/dev/null", "r" );
2267     if( file )
2268     {
2269         i_ret = fread( buf, 1, 20, file );
2270         if( i_ret > 0 )
2271         {
2272             buf[19] = '\0';
2273             psz_parser = strchr( buf, ' ' );
2274             if( psz_parser )
2275             {
2276                 i_ret = atoi( psz_parser + 1 );
2277                 if( i_ret >= 80 )
2278                 {
2279                     i_width = i_ret;
2280                 }
2281             }
2282         }
2283
2284         pclose( file );
2285     }
2286 #endif
2287
2288     return i_width;
2289 }
2290
2291 static int VerboseCallback( vlc_object_t *p_this, const char *psz_variable,
2292                      vlc_value_t old_val, vlc_value_t new_val, void *param)
2293 {
2294     vlc_t *p_vlc = (vlc_t *)p_this;
2295
2296     if( new_val.i_int >= -1 )
2297     {
2298         p_vlc->p_libvlc->i_verbose = __MIN( new_val.i_int, 2 );
2299     }
2300     return VLC_SUCCESS;
2301 }
2302
2303 /*****************************************************************************
2304  * InitDeviceValues: initialize device values
2305  *****************************************************************************
2306  * This function inits the dvd, vcd and cd-audio values
2307  *****************************************************************************/
2308 static void InitDeviceValues( vlc_t *p_vlc )
2309 {
2310 #ifdef HAVE_HAL
2311     LibHalContext * ctx;
2312     int i, i_devices;
2313     char **devices;
2314     char *block_dev;
2315     dbus_bool_t b_dvd;
2316
2317     if( ( ctx = hal_initialize( NULL, FALSE ) ) )
2318     {
2319         if( ( devices = hal_get_all_devices( ctx, &i_devices ) ) )
2320         {
2321             for( i = 0; i < i_devices; i++ )
2322             {
2323                 if( !hal_device_property_exists( ctx, devices[ i ],
2324                                                 "storage.cdrom.dvd" ) )
2325                 {
2326                     continue;
2327                 }
2328
2329                 b_dvd = hal_device_get_property_bool( ctx, devices[ i ],
2330                                                       "storage.cdrom.dvd" );
2331                 block_dev = hal_device_get_property_string( ctx, devices[ i ],
2332                                                             "block.device" );
2333
2334                 if( b_dvd )
2335                 {
2336                     config_PutPsz( p_vlc, "dvd", block_dev );
2337                 }
2338
2339                 config_PutPsz( p_vlc, "vcd", block_dev );
2340                 config_PutPsz( p_vlc, "cd-audio", block_dev );
2341
2342                 hal_free_string( block_dev );
2343             }
2344         }
2345
2346         hal_shutdown( ctx );
2347     }
2348 #endif
2349 }