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