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