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