]> git.sesse.net Git - vlc/blob - src/libvlc.c
fd50471d582ba0fb03952a47b639acfa9ccdfdc2
[vlc] / src / libvlc.c
1 /*****************************************************************************
2  * libvlc.c: main libvlc source
3  *****************************************************************************
4  * Copyright (C) 1998-2002 VideoLAN
5  * $Id: libvlc.c,v 1.100 2003/10/27 21:54:10 gbazin Exp $
6  *
7  * Authors: Vincent Seguin <seguin@via.ecp.fr>
8  *          Samuel Hocevar <sam@zoy.org>
9  *          Gildas Bazin <gbazin@netcourrier.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Pretend we are a builtin module
28  *****************************************************************************/
29 #define MODULE_NAME main
30 #define MODULE_PATH main
31 #define __BUILTIN__
32
33 /*****************************************************************************
34  * Preamble
35  *****************************************************************************/
36 #include <vlc/vlc.h>
37
38 #ifdef HAVE_ERRNO_H
39 #   include <errno.h>                                              /* ENOMEM */
40 #endif
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 #include "vlc_cpu.h"                                        /* CPU detection */
64 #include "os_specific.h"
65
66 #include "vlc_error.h"
67
68 #include "stream_control.h"
69 #include "input_ext-intf.h"
70
71 #include "vlc_playlist.h"
72 #include "vlc_interface.h"
73
74 #include "audio_output.h"
75
76 #include "vlc_video.h"
77 #include "video_output.h"
78
79 #include "libvlc.h"
80
81 /*****************************************************************************
82  * The evil global variable. We handle it with care, don't worry.
83  *****************************************************************************/
84 static libvlc_t   libvlc;
85 static libvlc_t * p_libvlc;
86 static vlc_t *    p_static_vlc;
87
88 /*****************************************************************************
89  * Local prototypes
90  *****************************************************************************/
91 static void SetLanguage   ( char const * );
92 static int  GetFilenames  ( vlc_t *, int, char *[] );
93 static void Usage         ( vlc_t *, char const *psz_module_name );
94 static void ListModules   ( vlc_t * );
95 static void Version       ( void );
96
97 #ifdef WIN32
98 static void ShowConsole   ( void );
99 #endif
100 static int  ConsoleWidth  ( void );
101
102
103 /*****************************************************************************
104  * vlc_current_object: return the current object.
105  *****************************************************************************
106  * If i_object is non-zero, return the corresponding object. Otherwise,
107  * return the statically allocated p_vlc object.
108  *****************************************************************************/
109 vlc_t * vlc_current_object( int i_object )
110 {
111     if( i_object )
112     {
113          return vlc_object_get( p_libvlc, i_object );
114     }
115
116     return p_static_vlc;
117 }
118
119 /*****************************************************************************
120  * VLC_Version: return the libvlc version.
121  *****************************************************************************
122  * This function returns full version string (numeric version and codename).
123  *****************************************************************************/
124 char const * VLC_Version( void )
125 {
126     return VERSION_MESSAGE;
127 }
128
129 /*****************************************************************************
130  * VLC_Error: strerror() equivalent
131  *****************************************************************************
132  * This function returns full version string (numeric version and codename).
133  *****************************************************************************/
134 char const * VLC_Error( int i_err )
135 {
136     return vlc_error( i_err );
137 }
138
139 /*****************************************************************************
140  * VLC_Create: allocate a vlc_t structure, and initialize libvlc if needed.
141  *****************************************************************************
142  * This function allocates a vlc_t structure and returns a negative value
143  * in case of failure. Also, the thread system is initialized.
144  *****************************************************************************/
145 int VLC_Create( void )
146 {
147     int i_ret;
148     vlc_t * p_vlc = NULL;
149     vlc_value_t lockval;
150
151     /* &libvlc never changes, so we can safely call this multiple times. */
152     p_libvlc = &libvlc;
153
154     /* vlc_threads_init *must* be the first internal call! No other call is
155      * allowed before the thread system has been initialized. */
156     i_ret = vlc_threads_init( p_libvlc );
157     if( i_ret < 0 )
158     {
159         return i_ret;
160     }
161
162     /* Now that the thread system is initialized, we don't have much, but
163      * at least we have var_Create */
164     var_Create( p_libvlc, "libvlc", VLC_VAR_MUTEX );
165     var_Get( p_libvlc, "libvlc", &lockval );
166     vlc_mutex_lock( lockval.p_address );
167     if( !libvlc.b_ready )
168     {
169         char *psz_env;
170
171         /* Guess what CPU we have */
172         libvlc.i_cpu = CPUCapabilities();
173
174         /* Find verbosity from VLC_VERBOSE environment variable */
175         psz_env = getenv( "VLC_VERBOSE" );
176         libvlc.i_verbose = psz_env ? atoi( psz_env ) : -1;
177
178 #if defined( HAVE_ISATTY ) && !defined( WIN32 )
179         libvlc.b_color = isatty( 2 ); /* 2 is for stderr */
180 #else
181         libvlc.b_color = VLC_FALSE;
182 #endif
183
184         /* Initialize message queue */
185         msg_Create( p_libvlc );
186
187         /* Announce who we are */
188         msg_Dbg( p_libvlc, COPYRIGHT_MESSAGE );
189         msg_Dbg( p_libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
190
191         /* The module bank will be initialized later */
192         libvlc.p_module_bank = NULL;
193
194         libvlc.b_ready = VLC_TRUE;
195     }
196     vlc_mutex_unlock( lockval.p_address );
197     var_Destroy( p_libvlc, "libvlc" );
198
199     /* Allocate a vlc object */
200     p_vlc = vlc_object_create( p_libvlc, VLC_OBJECT_VLC );
201     if( p_vlc == NULL )
202     {
203         return VLC_EGENERIC;
204     }
205     vlc_thread_set_priority( p_vlc, VLC_THREAD_PRIORITY_LOW );
206
207     p_vlc->psz_object_name = "root";
208
209     /* Initialize mutexes */
210     vlc_mutex_init( p_vlc, &p_vlc->config_lock );
211 #ifdef SYS_DARWIN
212     vlc_mutex_init( p_vlc, &p_vlc->quicktime_lock );
213 #endif
214
215     /* Store our newly allocated structure in the global list */
216     vlc_object_attach( p_vlc, p_libvlc );
217
218     /* Store data for the non-reentrant API */
219     p_static_vlc = p_vlc;
220
221     return p_vlc->i_object_id;
222 }
223
224 /*****************************************************************************
225  * VLC_Init: initialize a vlc_t structure.
226  *****************************************************************************
227  * This function initializes a previously allocated vlc_t structure:
228  *  - CPU detection
229  *  - gettext initialization
230  *  - message queue, module bank and playlist initialization
231  *  - configuration and commandline parsing
232  *****************************************************************************/
233 int VLC_Init( int i_object, int i_argc, char *ppsz_argv[] )
234 {
235     char         p_capabilities[200];
236     char *       p_tmp;
237     char *       psz_modules;
238     char *       psz_parser;
239     char *       psz_language;
240     vlc_bool_t   b_exit = VLC_FALSE;
241     vlc_t *      p_vlc = vlc_current_object( i_object );
242     module_t    *p_help_module;
243     playlist_t  *p_playlist;
244     vlc_value_t  lockval;
245
246     if( !p_vlc )
247     {
248         return VLC_ENOOBJ;
249     }
250
251     /*
252      * System specific initialization code
253      */
254     system_Init( p_vlc, &i_argc, ppsz_argv );
255
256     /* Get the executable name (similar to the basename command) */
257     if( i_argc > 0 )
258     {
259         p_vlc->psz_object_name = p_tmp = ppsz_argv[ 0 ];
260         while( *p_tmp )
261         {
262             if( *p_tmp == '/' ) p_vlc->psz_object_name = ++p_tmp;
263             else ++p_tmp;
264         }
265     }
266     else
267     {
268         p_vlc->psz_object_name = "vlc";
269     }
270
271     /*
272      * Support for gettext
273      */
274     SetLanguage( "" );
275
276     /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
277     msg_Dbg( p_vlc, "translation test: code is \"%s\"", _("C") );
278
279     /* Initialize the module bank and load the configuration of the
280      * main module. We need to do this at this stage to be able to display
281      * a short help if required by the user. (short help == main module
282      * options) */
283     var_Create( p_libvlc, "libvlc", VLC_VAR_MUTEX );
284     var_Get( p_libvlc, "libvlc", &lockval );
285     vlc_mutex_lock( lockval.p_address );
286     if( libvlc.p_module_bank == NULL )
287     {
288         module_InitBank( p_libvlc );
289         module_LoadMain( p_libvlc );
290     }
291     vlc_mutex_unlock( lockval.p_address );
292     var_Destroy( p_libvlc, "libvlc" );
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     config_Duplicate( p_help_module, p_help_config );
304     vlc_object_attach( p_help_module, libvlc.p_module_bank );
305     /* End hack */
306
307     if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE ) )
308     {
309         vlc_object_detach( p_help_module );
310         config_Free( p_help_module );
311         vlc_object_destroy( p_help_module );
312         /*module_EndBank( p_vlc );*/
313         if( i_object ) vlc_object_release( p_vlc );
314         return VLC_EGENERIC;
315     }
316
317     /* Check for short help option */
318     if( config_GetInt( p_vlc, "help" ) )
319     {
320         fprintf( stdout, _("Usage: %s [options] [items]...\n\n"),
321                          p_vlc->psz_object_name );
322         Usage( p_vlc, "main" );
323         Usage( p_vlc, "help" );
324         b_exit = VLC_TRUE;
325     }
326     /* Check for version option */
327     else if( config_GetInt( p_vlc, "version" ) )
328     {
329         Version();
330         b_exit = VLC_TRUE;
331     }
332
333     /* Set the config file stuff */
334     p_vlc->psz_homedir = config_GetHomeDir();
335     p_vlc->psz_configfile = config_GetPsz( p_vlc, "config" );
336
337     /* Hack: remove the help module here */
338     vlc_object_detach( p_help_module );
339     /* End hack */
340
341     if( b_exit )
342     {
343         config_Free( p_help_module );
344         vlc_object_destroy( p_help_module );
345         /*module_EndBank( p_vlc );*/
346         if( i_object ) vlc_object_release( p_vlc );
347         return VLC_EEXIT;
348     }
349
350     /* Check for translation config option */
351 #if defined( ENABLE_NLS ) \
352      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
353
354     /* This ain't really nice to have to reload the config here but it seems
355      * the only way to do it. */
356     config_LoadConfigFile( p_vlc, "main" );
357     config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
358
359     /* Check if the user specified a custom language */
360     psz_language = config_GetPsz( p_vlc, "language" );
361     if( psz_language && *psz_language && strcmp( psz_language, "auto" ) )
362     {
363         /* Reset the default domain */
364         SetLanguage( psz_language );
365
366         /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
367         msg_Dbg( p_vlc, "translation test: code is \"%s\"", _("C") );
368
369         textdomain( PACKAGE );
370
371 #if defined( SYS_BEOS ) || defined ( SYS_DARWIN ) || \
372     ( defined( WIN32 ) && !defined( HAVE_INCLUDED_GETTEXT ) )
373         /* BeOS only support UTF8 strings */
374         /* Mac OS X prefers UTF8 */
375         bind_textdomain_codeset( PACKAGE, "UTF-8" );
376 #endif
377
378         module_EndBank( p_vlc );
379         module_InitBank( p_libvlc );
380         module_LoadMain( p_libvlc );
381         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
382     }
383     if( psz_language ) free( psz_language );
384 #endif
385
386     /*
387      * Load the builtins and plugins into the module_bank.
388      * We have to do it before config_Load*() because this also gets the
389      * list of configuration options exported by each module and loads their
390      * default values.
391      */
392     module_LoadBuiltins( p_libvlc );
393     module_LoadPlugins( p_libvlc );
394     msg_Dbg( p_vlc, "module bank initialized, found %i modules",
395                     libvlc.p_module_bank->i_children );
396
397     /* Hack: insert the help module here */
398     vlc_object_attach( p_help_module, libvlc.p_module_bank );
399     /* End hack */
400
401     /* Check for help on modules */
402     if( (p_tmp = config_GetPsz( p_vlc, "module" )) )
403     {
404         Usage( p_vlc, p_tmp );
405         free( p_tmp );
406         b_exit = VLC_TRUE;
407     }
408     /* Check for long help option */
409     else if( config_GetInt( p_vlc, "longhelp" ) )
410     {
411         Usage( p_vlc, NULL );
412         b_exit = VLC_TRUE;
413     }
414     /* Check for module list option */
415     else if( config_GetInt( p_vlc, "list" ) )
416     {
417         ListModules( p_vlc );
418         b_exit = VLC_TRUE;
419     }
420
421     /* Check for config file options */
422     if( config_GetInt( p_vlc, "reset-config" ) )
423     {
424         vlc_object_detach( p_help_module );
425         config_ResetAll( p_vlc );
426         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
427         config_SaveConfigFile( p_vlc, NULL );
428         vlc_object_attach( p_help_module, libvlc.p_module_bank );
429     }
430     if( config_GetInt( p_vlc, "save-config" ) )
431     {
432         vlc_object_detach( p_help_module );
433         config_LoadConfigFile( p_vlc, NULL );
434         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
435         config_SaveConfigFile( p_vlc, NULL );
436         vlc_object_attach( p_help_module, libvlc.p_module_bank );
437     }
438
439     /* Hack: remove the help module here */
440     vlc_object_detach( p_help_module );
441     /* End hack */
442
443     if( b_exit )
444     {
445         config_Free( p_help_module );
446         vlc_object_destroy( p_help_module );
447         /*module_EndBank( p_vlc );*/
448         if( i_object ) vlc_object_release( p_vlc );
449         return VLC_EEXIT;
450     }
451
452     /*
453      * Override default configuration with config file settings
454      */
455     config_LoadConfigFile( p_vlc, NULL );
456
457     /* Hack: insert the help module here */
458     vlc_object_attach( p_help_module, libvlc.p_module_bank );
459     /* End hack */
460
461     /*
462      * Override configuration with command line settings
463      */
464     if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_FALSE ) )
465     {
466 #ifdef WIN32
467         ShowConsole();
468         /* Pause the console because it's destroyed when we exit */
469         fprintf( stderr, "The command line options couldn't be loaded, check "
470                  "that they are valid.\nPress the RETURN key to continue..." );
471         getchar();
472 #endif
473         vlc_object_detach( p_help_module );
474         config_Free( p_help_module );
475         vlc_object_destroy( p_help_module );
476         /*module_EndBank( p_vlc );*/
477         if( i_object ) vlc_object_release( p_vlc );
478         return VLC_EGENERIC;
479     }
480
481     /* Hack: remove the help module here */
482     vlc_object_detach( p_help_module );
483     config_Free( p_help_module );
484     vlc_object_destroy( p_help_module );
485     /* End hack */
486
487     /*
488      * System specific configuration
489      */
490     system_Configure( p_vlc, &i_argc, ppsz_argv );
491
492     /*
493      * Message queue options
494      */
495     if( config_GetInt( p_vlc, "quiet" ) )
496     {
497         libvlc.i_verbose = -1;
498     }
499     else
500     {
501         int i_tmp = config_GetInt( p_vlc, "verbose" );
502         if( i_tmp >= 0 )
503         {
504             libvlc.i_verbose = __MIN( i_tmp, 2 );
505         }
506     }
507     libvlc.b_color = libvlc.b_color && config_GetInt( p_vlc, "color" );
508
509     /*
510      * Output messages that may still be in the queue
511      */
512     msg_Flush( p_vlc );
513
514     /* p_vlc initialization. FIXME ? */
515
516 #if defined( __i386__ )
517     if( !config_GetInt( p_vlc, "mmx" ) )
518         libvlc.i_cpu &= ~CPU_CAPABILITY_MMX;
519     if( !config_GetInt( p_vlc, "3dn" ) )
520         libvlc.i_cpu &= ~CPU_CAPABILITY_3DNOW;
521     if( !config_GetInt( p_vlc, "mmxext" ) )
522         libvlc.i_cpu &= ~CPU_CAPABILITY_MMXEXT;
523     if( !config_GetInt( p_vlc, "sse" ) )
524         libvlc.i_cpu &= ~CPU_CAPABILITY_SSE;
525 #endif
526 #if defined( __powerpc__ ) || defined( SYS_DARWIN )
527     if( !config_GetInt( p_vlc, "altivec" ) )
528         libvlc.i_cpu &= ~CPU_CAPABILITY_ALTIVEC;
529 #endif
530
531 #define PRINT_CAPABILITY( capability, string )                              \
532     if( libvlc.i_cpu & capability )                                         \
533     {                                                                       \
534         strncat( p_capabilities, string " ",                                \
535                  sizeof(p_capabilities) - strlen(p_capabilities) );         \
536         p_capabilities[sizeof(p_capabilities) - 1] = '\0';                  \
537     }
538
539     p_capabilities[0] = '\0';
540     PRINT_CAPABILITY( CPU_CAPABILITY_486, "486" );
541     PRINT_CAPABILITY( CPU_CAPABILITY_586, "586" );
542     PRINT_CAPABILITY( CPU_CAPABILITY_PPRO, "Pentium Pro" );
543     PRINT_CAPABILITY( CPU_CAPABILITY_MMX, "MMX" );
544     PRINT_CAPABILITY( CPU_CAPABILITY_3DNOW, "3DNow!" );
545     PRINT_CAPABILITY( CPU_CAPABILITY_MMXEXT, "MMXEXT" );
546     PRINT_CAPABILITY( CPU_CAPABILITY_SSE, "SSE" );
547     PRINT_CAPABILITY( CPU_CAPABILITY_ALTIVEC, "AltiVec" );
548     PRINT_CAPABILITY( CPU_CAPABILITY_FPU, "FPU" );
549     msg_Dbg( p_vlc, "CPU has capabilities %s", p_capabilities );
550
551     /*
552      * Choose the best memcpy module
553      */
554     p_vlc->p_memcpy_module = module_Need( p_vlc, "memcpy", "$memcpy" );
555
556     if( p_vlc->pf_memcpy == NULL )
557     {
558         p_vlc->pf_memcpy = memcpy;
559     }
560
561     if( p_vlc->pf_memset == NULL )
562     {
563         p_vlc->pf_memset = memset;
564     }
565
566     /*
567      * Initialize hotkey handling
568      */
569     var_Create( p_vlc, "key-pressed", VLC_VAR_INTEGER );
570     /*
571      * Initialize playlist and get commandline files
572      */
573     p_playlist = playlist_Create( p_vlc );
574     if( !p_playlist )
575     {
576         msg_Err( p_vlc, "playlist initialization failed" );
577         if( p_vlc->p_memcpy_module != NULL )
578         {
579             module_Unneed( p_vlc, p_vlc->p_memcpy_module );
580         }
581         /*module_EndBank( p_vlc );*/
582         if( i_object ) vlc_object_release( p_vlc );
583         return VLC_EGENERIC;
584     }
585
586     /*
587      * Load background interfaces
588      */
589     psz_modules = config_GetPsz( p_vlc, "extraintf" );
590     psz_parser = psz_modules;
591     while ( psz_parser && *psz_parser )
592     {
593         char *psz_module, *psz_temp;
594         psz_module = psz_parser;
595         psz_parser = strchr( psz_module, ',' );
596         if ( psz_parser )
597         {
598             *psz_parser = '\0';
599             psz_parser++;
600         }
601         psz_temp = (char *)malloc( strlen(psz_module) + sizeof(",none") );
602         if( psz_temp )
603         {
604             sprintf( psz_temp, "%s,none", psz_module );
605             VLC_AddIntf( 0, psz_temp, VLC_FALSE );
606             free( psz_temp );
607         }
608     }
609     if ( psz_modules )
610     {
611         free( psz_modules );
612     }
613
614     /*
615      * Allways load the hotkeys interface if it exists
616      */
617     VLC_AddIntf( 0, "hotkeys,none", VLC_FALSE );
618
619     /*
620      * FIXME: kludge to use a p_vlc-local variable for the Mozilla plugin
621      */
622     var_Create( p_vlc, "drawable", VLC_VAR_INTEGER );
623     var_Create( p_vlc, "drawableredraw", VLC_VAR_INTEGER );
624     var_Create( p_vlc, "drawablet", VLC_VAR_INTEGER );
625     var_Create( p_vlc, "drawablel", VLC_VAR_INTEGER );
626     var_Create( p_vlc, "drawableb", VLC_VAR_INTEGER );
627     var_Create( p_vlc, "drawabler", VLC_VAR_INTEGER );
628     var_Create( p_vlc, "drawablex", VLC_VAR_INTEGER );
629     var_Create( p_vlc, "drawabley", VLC_VAR_INTEGER );
630     var_Create( p_vlc, "drawablew", VLC_VAR_INTEGER );
631     var_Create( p_vlc, "drawableh", VLC_VAR_INTEGER );
632     var_Create( p_vlc, "drawableportx", VLC_VAR_INTEGER );
633     var_Create( p_vlc, "drawableporty", VLC_VAR_INTEGER );
634
635     /*
636      * Get input filenames given as commandline arguments
637      */
638     GetFilenames( p_vlc, i_argc, ppsz_argv );
639
640     if( i_object ) vlc_object_release( p_vlc );
641     return VLC_SUCCESS;
642 }
643
644 /*****************************************************************************
645  * VLC_AddIntf: add an interface
646  *****************************************************************************
647  * This function opens an interface plugin and runs it. If b_block is set
648  * to 0, VLC_AddIntf will return immediately and let the interface run in a
649  * separate thread. If b_block is set to 1, VLC_AddIntf will continue until
650  * user requests to quit.
651  *****************************************************************************/
652 int VLC_AddIntf( int i_object, char const *psz_module, vlc_bool_t b_block )
653 {
654     int i_err;
655     intf_thread_t *p_intf;
656     vlc_t *p_vlc = vlc_current_object( i_object );
657
658     if( !p_vlc )
659     {
660         return VLC_ENOOBJ;
661     }
662
663     /* Try to create the interface */
664     p_intf = intf_Create( p_vlc, psz_module ? psz_module : "$intf" );
665
666     if( p_intf == NULL )
667     {
668         msg_Err( p_vlc, "interface \"%s\" initialization failed", psz_module );
669         if( i_object ) vlc_object_release( p_vlc );
670         return VLC_EGENERIC;
671     }
672
673     /* Try to run the interface */
674     p_intf->b_block = b_block;
675     i_err = intf_RunThread( p_intf );
676     if( i_err )
677     {
678         vlc_object_detach( p_intf );
679         intf_Destroy( p_intf );
680         if( i_object ) vlc_object_release( p_vlc );
681         return i_err;
682     }
683
684     if( i_object ) vlc_object_release( p_vlc );
685     return VLC_SUCCESS;
686 }
687
688 /*****************************************************************************
689  * VLC_Destroy: stop playing and destroy everything.
690  *****************************************************************************
691  * This function requests the running threads to finish, waits for their
692  * termination, and destroys their structure.
693  *****************************************************************************/
694 int VLC_Destroy( int i_object )
695 {
696     vlc_t *p_vlc = vlc_current_object( i_object );
697
698     if( !p_vlc )
699     {
700         return VLC_ENOOBJ;
701     }
702
703     /*
704      * Free allocated memory
705      */
706     if( p_vlc->p_memcpy_module )
707     {
708         module_Unneed( p_vlc, p_vlc->p_memcpy_module );
709         p_vlc->p_memcpy_module = NULL;
710     }
711
712     if( p_vlc->psz_homedir )
713     {
714         free( p_vlc->psz_homedir );
715         p_vlc->psz_homedir = NULL;
716     }
717
718     if( p_vlc->psz_configfile )
719     {
720         free( p_vlc->psz_configfile );
721         p_vlc->psz_configfile = NULL;
722     }
723
724     /*
725      * XXX: Free module bank !
726      */
727     /*module_EndBank( p_vlc );*/
728
729     /*
730      * System specific cleaning code
731      */
732     system_End( p_vlc );
733
734     /* Destroy mutexes */
735     vlc_mutex_destroy( &p_vlc->config_lock );
736 #ifdef SYS_DARWIN
737     vlc_mutex_destroy( &p_vlc->quicktime_lock );
738 #endif
739
740     vlc_object_detach( p_vlc );
741
742     /* Release object before destroying it */
743     if( i_object ) vlc_object_release( p_vlc );
744
745     vlc_object_destroy( p_vlc );
746
747     /* Stop thread system: last one out please shut the door! */
748     vlc_threads_end( p_libvlc );
749
750     return VLC_SUCCESS;
751 }
752
753 /*****************************************************************************
754  * VLC_Die: ask vlc to die.
755  *****************************************************************************
756  * This function sets p_vlc->b_die to VLC_TRUE, but does not do any other
757  * task. It is your duty to call vlc_end and VLC_Destroy afterwards.
758  *****************************************************************************/
759 int VLC_Die( int i_object )
760 {
761     vlc_t *p_vlc = vlc_current_object( i_object );
762
763     if( !p_vlc )
764     {
765         return VLC_ENOOBJ;
766     }
767
768     p_vlc->b_die = VLC_TRUE;
769
770     if( i_object ) vlc_object_release( p_vlc );
771     return VLC_SUCCESS;
772 }
773
774 /*****************************************************************************
775  * VLC_AddTarget: adds a target for playing.
776  *****************************************************************************
777  * This function adds psz_target to the current playlist. If a playlist does
778  * not exist, it will create one.
779  *****************************************************************************/
780 int VLC_AddTarget( int i_object, char const *psz_target,
781                    char const **ppsz_options, int i_options,
782                    int i_mode, int i_pos )
783 {
784     int i_err;
785     playlist_t *p_playlist;
786     vlc_t *p_vlc = vlc_current_object( i_object );
787
788     if( !p_vlc )
789     {
790         return VLC_ENOOBJ;
791     }
792
793     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
794
795     if( p_playlist == NULL )
796     {
797         msg_Dbg( p_vlc, "no playlist present, creating one" );
798         p_playlist = playlist_Create( p_vlc );
799
800         if( p_playlist == NULL )
801         {
802             if( i_object ) vlc_object_release( p_vlc );
803             return VLC_EGENERIC;
804         }
805
806         vlc_object_yield( p_playlist );
807     }
808
809     i_err = playlist_Add( p_playlist, psz_target, ppsz_options, i_options,
810                           i_mode, i_pos );
811
812     vlc_object_release( p_playlist );
813
814     if( i_object ) vlc_object_release( p_vlc );
815     return i_err;
816 }
817
818 /*****************************************************************************
819  * VLC_Set: set a vlc variable
820  *****************************************************************************
821  *
822  *****************************************************************************/
823 int VLC_Set( int i_object, char const *psz_var, vlc_value_t value )
824 {
825     vlc_t *p_vlc = vlc_current_object( i_object );
826     int i_ret;
827
828     if( !p_vlc )
829     {
830         return VLC_ENOOBJ;
831     }
832
833     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
834      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
835     if( !strncmp( psz_var, "conf::", 6 ) )
836     {
837         module_config_t *p_item;
838         char const *psz_newvar = psz_var + 6;
839
840         p_item = config_FindConfig( VLC_OBJECT(p_vlc), psz_newvar );
841
842         if( p_item )
843         {
844             switch( p_item->i_type )
845             {
846                 case CONFIG_ITEM_BOOL:
847                     config_PutInt( p_vlc, psz_newvar, value.b_bool );
848                     break;
849                 case CONFIG_ITEM_INTEGER:
850                     config_PutInt( p_vlc, psz_newvar, value.i_int );
851                     break;
852                 case CONFIG_ITEM_FLOAT:
853                     config_PutFloat( p_vlc, psz_newvar, value.f_float );
854                     break;
855                 default:
856                     config_PutPsz( p_vlc, psz_newvar, value.psz_string );
857                     break;
858             }
859             if( i_object ) vlc_object_release( p_vlc );
860             return VLC_SUCCESS;
861         }
862     }
863
864     i_ret = var_Set( p_vlc, psz_var, value );
865
866     if( i_object ) vlc_object_release( p_vlc );
867     return i_ret;
868 }
869
870 /*****************************************************************************
871  * VLC_Get: get a vlc variable
872  *****************************************************************************
873  *
874  *****************************************************************************/
875 int VLC_Get( int i_object, char const *psz_var, vlc_value_t *p_value )
876 {
877     vlc_t *p_vlc = vlc_current_object( i_object );
878     int i_ret;
879
880     if( !p_vlc )
881     {
882         return VLC_ENOOBJ;
883     }
884
885     i_ret = var_Get( p_vlc, psz_var, p_value );
886
887     if( i_object ) vlc_object_release( p_vlc );
888     return i_ret;
889 }
890
891 /* FIXME: temporary hacks */
892
893 /*****************************************************************************
894  * VLC_Play: play
895  *****************************************************************************/
896 int VLC_Play( int i_object )
897 {
898     playlist_t * p_playlist;
899     vlc_t *p_vlc = vlc_current_object( i_object );
900
901     /* Check that the handle is valid */
902     if( !p_vlc )
903     {
904         return VLC_ENOOBJ;
905     }
906
907     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
908
909     if( !p_playlist )
910     {
911         if( i_object ) vlc_object_release( p_vlc );
912         return VLC_ENOOBJ;
913     }
914
915     vlc_mutex_lock( &p_playlist->object_lock );
916     if( p_playlist->i_size )
917     {
918         vlc_mutex_unlock( &p_playlist->object_lock );
919         playlist_Play( p_playlist );
920     }
921     else
922     {
923         vlc_mutex_unlock( &p_playlist->object_lock );
924     }
925
926     vlc_object_release( p_playlist );
927
928     if( i_object ) vlc_object_release( p_vlc );
929     return VLC_SUCCESS;
930 }
931
932 /*****************************************************************************
933  * VLC_Stop: stop
934  *****************************************************************************/
935 int VLC_Stop( int i_object )
936 {
937     intf_thread_t *   p_intf;
938     playlist_t    *   p_playlist;
939     vout_thread_t *   p_vout;
940     aout_instance_t * p_aout;
941     vlc_t *p_vlc = vlc_current_object( i_object );
942
943     /* Check that the handle is valid */
944     if( !p_vlc )
945     {
946         return VLC_ENOOBJ;
947     }
948
949     /*
950      * Ask the interfaces to stop and destroy them
951      */
952     msg_Dbg( p_vlc, "removing all interfaces" );
953
954     while( (p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_CHILD )) )
955     {
956         intf_StopThread( p_intf );
957         vlc_object_detach( p_intf );
958         vlc_object_release( p_intf );
959         intf_Destroy( p_intf );
960     }
961
962     /*
963      * Free playlists
964      */
965     
966     msg_Dbg( p_vlc, "removing all playlists" );
967     while( (p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST,
968                                           FIND_CHILD )) )
969     {
970         vlc_object_detach( p_playlist );
971         vlc_object_release( p_playlist );
972         playlist_Destroy( p_playlist );
973     }
974     
975     /*
976      * Free video outputs
977      */
978     msg_Dbg( p_vlc, "removing all video outputs" );
979     while( (p_vout = vlc_object_find( p_vlc, VLC_OBJECT_VOUT, FIND_CHILD )) )
980     {
981         vlc_object_detach( p_vout );
982         vlc_object_release( p_vout );
983         vout_Destroy( p_vout );
984     }
985
986     /*
987      * Free audio outputs
988      */
989     msg_Dbg( p_vlc, "removing all audio outputs" );
990     while( (p_aout = vlc_object_find( p_vlc, VLC_OBJECT_AOUT, FIND_CHILD )) )
991     {
992         vlc_object_detach( (vlc_object_t *)p_aout );
993         vlc_object_release( (vlc_object_t *)p_aout );
994         aout_Delete( p_aout );
995     }
996
997     if( i_object ) vlc_object_release( p_vlc );
998     return VLC_SUCCESS;
999 }
1000
1001 /*****************************************************************************
1002  * VLC_Pause: toggle pause
1003  *****************************************************************************/
1004 int VLC_Pause( int i_object )
1005 {
1006     input_thread_t *p_input;
1007     vlc_t *p_vlc = vlc_current_object( i_object );
1008
1009     if( !p_vlc )
1010     {
1011         return VLC_ENOOBJ;
1012     }
1013
1014     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1015
1016     if( !p_input )
1017     {
1018         if( i_object ) vlc_object_release( p_vlc );
1019         return VLC_ENOOBJ;
1020     }
1021
1022     input_SetStatus( p_input, INPUT_STATUS_PAUSE );
1023     vlc_object_release( p_input );
1024
1025     if( i_object ) vlc_object_release( p_vlc );
1026     return VLC_SUCCESS;
1027 }
1028
1029 /*****************************************************************************
1030  * VLC_FullScreen: toggle fullscreen mode
1031  *****************************************************************************/
1032 int VLC_FullScreen( int i_object )
1033 {
1034     vout_thread_t *p_vout;
1035     vlc_t *p_vlc = vlc_current_object( i_object );
1036
1037     if( !p_vlc )
1038     {
1039         return VLC_ENOOBJ;
1040     }
1041
1042     p_vout = vlc_object_find( p_vlc, VLC_OBJECT_VOUT, FIND_CHILD );
1043
1044     if( !p_vout )
1045     {
1046         if( i_object ) vlc_object_release( p_vlc );
1047         return VLC_ENOOBJ;
1048     }
1049
1050     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
1051     vlc_object_release( p_vout );
1052
1053     if( i_object ) vlc_object_release( p_vlc );
1054     return VLC_SUCCESS;
1055 }
1056
1057 /* following functions are local */
1058
1059 /*****************************************************************************
1060  * SetLanguage: set the interface language.
1061  *****************************************************************************
1062  * We set the LC_MESSAGES locale category for interface messages and buttons,
1063  * as well as the LC_CTYPE category for string sorting and possible wide
1064  * character support.
1065  *****************************************************************************/
1066 static void SetLanguage ( char const *psz_lang )
1067 {
1068 #if defined( ENABLE_NLS ) \
1069      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
1070
1071     char *          psz_path;
1072 #if defined( SYS_DARWIN ) || defined ( WIN32 ) || defined( SYS_BEOS )
1073     char            psz_tmp[1024];
1074 #endif
1075
1076     if( psz_lang && !*psz_lang )
1077     {
1078 #   if defined( HAVE_LC_MESSAGES )
1079         setlocale( LC_MESSAGES, psz_lang );
1080 #   endif
1081         setlocale( LC_CTYPE, psz_lang );
1082     }
1083     else if( psz_lang )
1084     {
1085 #ifdef SYS_DARWIN
1086         /* I need that under Darwin, please check it doesn't disturb
1087          * other platforms. --Meuuh */
1088         setenv( "LANG", psz_lang, 1 );
1089
1090 #elif defined( SYS_BEOS ) || defined( WIN32 )
1091         /* We set LC_ALL manually because it is the only way to set
1092          * the language at runtime under eg. Windows. Beware that this
1093          * makes the environment unconsistent when libvlc is unloaded and
1094          * should probably be moved to a safer place like vlc.c. */
1095         static char psz_lcall[20];
1096         snprintf( psz_lcall, 19, "LC_ALL=%s", psz_lang );
1097         psz_lcall[19] = '\0';
1098         putenv( psz_lcall );
1099 #endif
1100
1101         setlocale( LC_ALL, psz_lang );
1102     }
1103
1104     /* Specify where to find the locales for current domain */
1105 #if !defined( SYS_DARWIN ) && !defined( WIN32 ) && !defined( SYS_BEOS )
1106     psz_path = LOCALEDIR;
1107 #else
1108     snprintf( psz_tmp, sizeof(psz_tmp), "%s/%s", libvlc.psz_vlcpath,
1109               "locale" );
1110     psz_path = psz_tmp;
1111 #endif
1112     if( !bindtextdomain( PACKAGE, psz_path ) )
1113     {
1114         fprintf( stderr, "warning: no domain %s in directory %s\n",
1115                  PACKAGE, psz_path );
1116     }
1117
1118     /* Set the default domain */
1119     textdomain( PACKAGE );
1120
1121 #if defined( SYS_BEOS ) || defined ( SYS_DARWIN ) || \
1122     ( defined( WIN32 ) && !defined( HAVE_INCLUDED_GETTEXT ) )
1123     /* BeOS only support UTF8 strings */
1124     /* Mac OS X prefers UTF8 */
1125     bind_textdomain_codeset( PACKAGE, "UTF-8" );
1126 #endif
1127
1128 #endif
1129 }
1130
1131 /*****************************************************************************
1132  * GetFilenames: parse command line options which are not flags
1133  *****************************************************************************
1134  * Parse command line for input files as well as their associated options.
1135  * An option always follows its associated input and begins with a ":".
1136  *****************************************************************************/
1137 static int GetFilenames( vlc_t *p_vlc, int i_argc, char *ppsz_argv[] )
1138 {
1139     int i_opt, i_options;
1140
1141     /* We assume that the remaining parameters are filenames
1142      * and their input options */
1143     for( i_opt = i_argc - 1; i_opt >= optind; i_opt-- )
1144     {
1145         i_options = 0;
1146
1147         /* Count the input options */
1148         while( *ppsz_argv[ i_opt ] == ':' && i_opt > optind )
1149         {
1150             i_options++;
1151             i_opt--;
1152         }
1153
1154         /* TODO: write an internal function of this one, to avoid
1155          *       unnecessary lookups. */
1156         VLC_AddTarget( p_vlc->i_object_id, ppsz_argv[ i_opt ],
1157                        (char const **)( i_options ? &ppsz_argv[i_opt + 1] :
1158                                         NULL ), i_options,
1159                        PLAYLIST_INSERT | (i_opt == optind ? PLAYLIST_GO : 0),
1160                        0 );
1161     }
1162
1163     return VLC_SUCCESS;
1164 }
1165
1166 /*****************************************************************************
1167  * Usage: print program usage
1168  *****************************************************************************
1169  * Print a short inline help. Message interface is initialized at this stage.
1170  *****************************************************************************/
1171 static void Usage( vlc_t *p_this, char const *psz_module_name )
1172 {
1173 #define FORMAT_STRING "  %s --%s%s%s%s%s%s%s "
1174     /* short option ------'    |     | | | |  | |
1175      * option name ------------'     | | | |  | |
1176      * <bra -------------------------' | | |  | |
1177      * option type or "" --------------' | |  | |
1178      * ket> -----------------------------' |  | |
1179      * padding spaces ---------------------'  | |
1180      * comment -------------------------------' |
1181      * comment suffix --------------------------'
1182      *
1183      * The purpose of having bra and ket is that we might i18n them as well.
1184      */
1185 #define LINE_START 8
1186 #define PADDING_SPACES 25
1187     vlc_list_t *p_list;
1188     module_t *p_parser;
1189     module_config_t *p_item;
1190     char psz_spaces[PADDING_SPACES+LINE_START+1];
1191     char psz_format[sizeof(FORMAT_STRING)];
1192     char psz_buffer[1000];
1193     char psz_short[4];
1194     int i_index;
1195     int i_width = ConsoleWidth() - (PADDING_SPACES+LINE_START+1);
1196
1197     memset( psz_spaces, ' ', PADDING_SPACES+LINE_START );
1198     psz_spaces[PADDING_SPACES+LINE_START] = '\0';
1199
1200     strcpy( psz_format, FORMAT_STRING );
1201
1202 #ifdef WIN32
1203     ShowConsole();
1204 #endif
1205
1206     /* List all modules */
1207     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1208
1209     /* Enumerate the config for each module */
1210     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1211     {
1212         vlc_bool_t b_help_module;
1213
1214         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1215
1216         if( psz_module_name && strcmp( psz_module_name,
1217                                        p_parser->psz_object_name ) )
1218         {
1219             continue;
1220         }
1221
1222         /* Ignore modules without config options */
1223         if( !p_parser->i_config_items )
1224         {
1225             continue;
1226         }
1227
1228         b_help_module = !strcmp( "help", p_parser->psz_object_name );
1229
1230         /* Print module options */
1231         for( p_item = p_parser->p_config;
1232              p_item->i_type != CONFIG_HINT_END;
1233              p_item++ )
1234         {
1235             char *psz_text;
1236             char *psz_bra = NULL, *psz_type = NULL, *psz_ket = NULL;
1237             char *psz_suf = "", *psz_prefix = NULL;
1238             int i;
1239             if ( p_item->b_advanced && !config_GetInt( p_this, "advanced" ))
1240             {
1241                 continue;
1242             }
1243             switch( p_item->i_type )
1244             {
1245             case CONFIG_HINT_CATEGORY:
1246             case CONFIG_HINT_USAGE:
1247                 fprintf( stdout, " %s\n", p_item->psz_text );
1248                 break;
1249
1250             case CONFIG_ITEM_STRING:
1251             case CONFIG_ITEM_FILE:
1252             case CONFIG_ITEM_MODULE: /* We could also have "=<" here */
1253                 if( !p_item->ppsz_list )
1254                 {
1255                     psz_bra = " <"; psz_type = _("string"); psz_ket = ">";
1256                     break;
1257                 }
1258                 else
1259                 {
1260                     psz_bra = " {";
1261                     psz_type = psz_buffer;
1262                     psz_type[0] = '\0';
1263                     for( i = 0; p_item->ppsz_list[i]; i++ )
1264                     {
1265                         if( i ) strcat( psz_type, "," );
1266                         strcat( psz_type, p_item->ppsz_list[i] );
1267                     }
1268                     psz_ket = "}";
1269                     break;
1270                 }
1271             case CONFIG_ITEM_INTEGER:
1272                 psz_bra = " <"; psz_type = _("integer"); psz_ket = ">";
1273                 break;
1274             case CONFIG_ITEM_FLOAT:
1275                 psz_bra = " <"; psz_type = _("float"); psz_ket = ">";
1276                 break;
1277             case CONFIG_ITEM_BOOL:
1278                 psz_bra = ""; psz_type = ""; psz_ket = "";
1279                 if( !b_help_module )
1280                 {
1281                     psz_suf = p_item->i_value ? _(" (default enabled)") :
1282                                                 _(" (default disabled)");
1283                 }
1284                 break;
1285             }
1286
1287             if( !psz_type )
1288             {
1289                 continue;
1290             }
1291
1292             /* Add short option if any */
1293             if( p_item->i_short )
1294             {
1295                 sprintf( psz_short, "-%c,", p_item->i_short );
1296             }
1297             else
1298             {
1299                 strcpy( psz_short, "   " );
1300             }
1301
1302             i = PADDING_SPACES - strlen( p_item->psz_name )
1303                  - strlen( psz_bra ) - strlen( psz_type )
1304                  - strlen( psz_ket ) - 1;
1305
1306             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
1307             {
1308                 /* If option is of type --foo-bar, we print its counterpart
1309                  * as --no-foo-bar, but if it is of type --foobar (without
1310                  * dashes in the name) we print it as --nofoobar. Both
1311                  * values are of course valid, only the display changes. */
1312                 psz_prefix = strchr( p_item->psz_name, '-' ) ? ", --no-"
1313                                                              : ", --no";
1314                 i -= strlen( p_item->psz_name ) + strlen( psz_prefix );
1315             }
1316
1317             if( i < 0 )
1318             {
1319                 psz_spaces[0] = '\n';
1320                 i = 0;
1321             }
1322             else
1323             {
1324                 psz_spaces[i] = '\0';
1325             }
1326
1327             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
1328             {
1329                 fprintf( stdout, psz_format, psz_short, p_item->psz_name,
1330                          psz_prefix, p_item->psz_name, psz_bra, psz_type,
1331                          psz_ket, psz_spaces );
1332             }
1333             else
1334             {
1335                 fprintf( stdout, psz_format, psz_short, p_item->psz_name,
1336                          "", "", psz_bra, psz_type, psz_ket, psz_spaces );
1337             }
1338
1339             psz_spaces[i] = ' ';
1340
1341             /* We wrap the rest of the output */
1342             sprintf( psz_buffer, "%s%s", p_item->psz_text, psz_suf );
1343             psz_text = psz_buffer;
1344             while( *psz_text )
1345             {
1346                 char *psz_parser, *psz_word;
1347                 int i_end = strlen( psz_text );
1348
1349                 /* If the remaining text fits in a line, print it. */
1350                 if( i_end <= i_width )
1351                 {
1352                     fprintf( stdout, "%s\n", psz_text );
1353                     break;
1354                 }
1355
1356                 /* Otherwise, eat as many words as possible */
1357                 psz_parser = psz_text;
1358                 do
1359                 {
1360                     psz_word = psz_parser;
1361                     psz_parser = strchr( psz_word, ' ' );
1362                     /* If no space was found, we reached the end of the text
1363                      * block; otherwise, we skip the space we just found. */
1364                     psz_parser = psz_parser ? psz_parser + 1
1365                                             : psz_text + i_end;
1366
1367                 } while( psz_parser - psz_text <= i_width );
1368
1369                 /* We cut a word in one of these cases:
1370                  *  - it's the only word in the line and it's too long.
1371                  *  - we used less than 80% of the width and the word we are
1372                  *    going to wrap is longer than 40% of the width, and even
1373                  *    if the word would have fit in the next line. */
1374                 if( psz_word == psz_text
1375                      || ( psz_word - psz_text < 80 * i_width / 100
1376                            && psz_parser - psz_word > 40 * i_width / 100 ) )
1377                 {
1378                     char c = psz_text[i_width];
1379                     psz_text[i_width] = '\0';
1380                     fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
1381                     psz_text += i_width;
1382                     psz_text[0] = c;
1383                 }
1384                 else
1385                 {
1386                     psz_word[-1] = '\0';
1387                     fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
1388                     psz_text = psz_word;
1389                 }
1390             }
1391         }
1392     }
1393
1394     /* Release the module list */
1395     vlc_list_release( p_list );
1396
1397 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
1398     fprintf( stdout, _("\nPress the RETURN key to continue...\n") );
1399     getchar();
1400 #endif
1401 }
1402
1403 /*****************************************************************************
1404  * ListModules: list the available modules with their description
1405  *****************************************************************************
1406  * Print a list of all available modules (builtins and plugins) and a short
1407  * description for each one.
1408  *****************************************************************************/
1409 static void ListModules( vlc_t *p_this )
1410 {
1411     vlc_list_t *p_list;
1412     module_t *p_parser;
1413     char psz_spaces[22];
1414     int i_index;
1415
1416     memset( psz_spaces, ' ', 22 );
1417
1418 #ifdef WIN32
1419     ShowConsole();
1420 #endif
1421
1422     /* Usage */
1423     fprintf( stdout, _("Usage: %s [options] [items]...\n\n"),
1424                      p_this->p_vlc->psz_object_name );
1425
1426     fprintf( stdout, _("[module]              [description]\n") );
1427
1428     /* List all modules */
1429     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1430
1431     /* Enumerate each module */
1432     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1433     {
1434         int i;
1435
1436         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1437
1438         /* Nasty hack, but right now I'm too tired to think about a nice
1439          * solution */
1440         i = 22 - strlen( p_parser->psz_object_name ) - 1;
1441         if( i < 0 ) i = 0;
1442         psz_spaces[i] = 0;
1443
1444         fprintf( stdout, "  %s%s %s\n", p_parser->psz_object_name,
1445                          psz_spaces, p_parser->psz_longname );
1446
1447         psz_spaces[i] = ' ';
1448     }
1449
1450     vlc_list_release( p_list );
1451
1452 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
1453     fprintf( stdout, _("\nPress the RETURN key to continue...\n") );
1454     getchar();
1455 #endif
1456 }
1457
1458 /*****************************************************************************
1459  * Version: print complete program version
1460  *****************************************************************************
1461  * Print complete program version and build number.
1462  *****************************************************************************/
1463 static void Version( void )
1464 {
1465 #ifdef WIN32
1466     ShowConsole();
1467 #endif
1468
1469     fprintf( stdout, VERSION_MESSAGE "\n" );
1470     fprintf( stdout,
1471       _("This program comes with NO WARRANTY, to the extent permitted by "
1472         "law.\nYou may redistribute it under the terms of the GNU General "
1473         "Public License;\nsee the file named COPYING for details.\n"
1474         "Written by the VideoLAN team at Ecole Centrale, Paris.\n") );
1475
1476 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
1477     fprintf( stdout, _("\nPress the RETURN key to continue...\n") );
1478     getchar();
1479 #endif
1480 }
1481
1482 /*****************************************************************************
1483  * ShowConsole: On Win32, create an output console for debug messages
1484  *****************************************************************************
1485  * This function is useful only on Win32.
1486  *****************************************************************************/
1487 #ifdef WIN32 /*  */
1488 static void ShowConsole( void )
1489 {
1490 #   ifndef UNDER_CE
1491     AllocConsole();
1492     freopen( "CONOUT$", "w", stdout );
1493     freopen( "CONOUT$", "w", stderr );
1494     freopen( "CONIN$", "r", stdin );
1495 #   endif
1496     return;
1497 }
1498 #endif
1499
1500 /*****************************************************************************
1501  * ConsoleWidth: Return the console width in characters
1502  *****************************************************************************
1503  * We use the stty shell command to get the console width; if this fails or
1504  * if the width is less than 80, we default to 80.
1505  *****************************************************************************/
1506 static int ConsoleWidth( void )
1507 {
1508     int i_width = 80;
1509
1510 #ifndef WIN32
1511     char buf[20], *psz_parser;
1512     FILE *file;
1513     int i_ret;
1514
1515     file = popen( "stty size 2>/dev/null", "r" );
1516     if( file )
1517     {
1518         i_ret = fread( buf, 1, 20, file );
1519         if( i_ret > 0 )
1520         {
1521             buf[19] = '\0';
1522             psz_parser = strchr( buf, ' ' );
1523             if( psz_parser )
1524             {
1525                 i_ret = atoi( psz_parser + 1 );
1526                 if( i_ret >= 80 )
1527                 {
1528                     i_width = i_ret;
1529                 }
1530             }
1531         }
1532
1533         pclose( file );
1534     }
1535 #endif
1536
1537     return i_width;
1538 }