Unbreak ffed6142d652bb8154dbeac565000ea3673722a0
[vlc.git] / src / libvlc-common.c
1 /*****************************************************************************
2  * libvlc-common.c: libvlc instances creation and deletion, interfaces handling
3  *****************************************************************************
4  * Copyright (C) 1998-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Vincent Seguin <seguin@via.ecp.fr>
8  *          Samuel Hocevar <sam@zoy.org>
9  *          Gildas Bazin <gbazin@videolan.org>
10  *          Derk-Jan Hartman <hartman at videolan dot org>
11  *          RĂ©mi Denis-Courmont <rem # videolan : org>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27
28 /** \file
29  * This file contains functions to create and destroy libvlc instances
30  */
31
32 /*****************************************************************************
33  * Preamble
34  *****************************************************************************/
35 #ifdef HAVE_CONFIG_H
36 # include "config.h"
37 #endif
38
39 #include <vlc/vlc.h>
40 #include "control/libvlc_internal.h"
41 #include <vlc_input.h>
42
43 #include "modules/modules.h"
44 #include "config/configuration.h"
45 #include "interface/interface.h"
46
47 #include <errno.h>                                                 /* ENOMEM */
48 #include <stdio.h>                                              /* sprintf() */
49 #include <string.h>
50 #include <stdlib.h>                                                /* free() */
51
52 #ifndef WIN32
53 #   include <netinet/in.h>                            /* BSD: struct in_addr */
54 #endif
55
56 #ifdef HAVE_UNISTD_H
57 #   include <unistd.h>
58 #elif defined( WIN32 ) && !defined( UNDER_CE )
59 #   include <io.h>
60 #endif
61
62 #ifdef WIN32                       /* optind, getopt(), included in unistd.h */
63 #   include "extras/getopt.h"
64 #endif
65
66 #ifdef HAVE_LOCALE_H
67 #   include <locale.h>
68 #endif
69
70 #ifdef HAVE_DBUS_3
71 /* used for one-instance mode */
72 #   include <dbus/dbus.h>
73 #endif
74
75 #ifdef HAVE_HAL
76 #   include <hal/libhal.h>
77 #endif
78
79 #include <vlc_playlist.h>
80 #include <vlc_interface.h>
81
82 #include <vlc_aout.h>
83 #include "audio_output/aout_internal.h"
84
85 #include <vlc_vout.h>
86
87 #include <vlc_sout.h>
88 #include "stream_output/stream_output.h"
89
90 #include <vlc_charset.h>
91
92 #include "libvlc.h"
93
94 #include "playlist/playlist_internal.h"
95
96 #include <vlc_vlm.h>
97
98 #include <assert.h>
99
100 /*****************************************************************************
101  * The evil global variables. We handle them with care, don't worry.
102  *****************************************************************************/
103 static libvlc_int_t *    p_static_vlc = NULL;
104 static unsigned          i_instances = 0;
105
106 static bool b_daemon = false;
107
108 /*****************************************************************************
109  * Local prototypes
110  *****************************************************************************/
111 #if defined( ENABLE_NLS ) && (defined (__APPLE__) || defined (WIN32)) && \
112     ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
113 static void SetLanguage   ( char const * );
114 #endif
115 static inline int LoadMessages (void);
116 static int  GetFilenames  ( libvlc_int_t *, int, const char *[] );
117 static void Help          ( libvlc_int_t *, char const *psz_help_name );
118 static void Usage         ( libvlc_int_t *, char const *psz_module_name );
119 static void ListModules   ( libvlc_int_t *, bool );
120 static void Version       ( void );
121
122 #ifdef WIN32
123 static void ShowConsole   ( bool );
124 static void PauseConsole  ( void );
125 #endif
126 static int  ConsoleWidth  ( void );
127
128 static int  VerboseCallback( vlc_object_t *, char const *,
129                              vlc_value_t, vlc_value_t, void * );
130
131 static void InitDeviceValues( libvlc_int_t * );
132
133 /*****************************************************************************
134  * vlc_current_object: return the current object.
135  *****************************************************************************
136  * If i_object is non-zero, return the corresponding object. Otherwise,
137  * return the statically allocated p_vlc object.
138  *****************************************************************************/
139 libvlc_int_t * vlc_current_object( int i_object )
140 {
141     return i_object ? vlc_object_get( i_object ) : p_static_vlc;
142 }
143
144
145 /**
146  * Allocate a libvlc instance, initialize global data if needed
147  * It also initializes the threading system
148  */
149 libvlc_int_t * libvlc_InternalCreate( void )
150 {
151     libvlc_int_t *p_libvlc;
152     libvlc_priv_t *priv;
153     char *psz_env = NULL;
154
155     /* vlc_threads_init *must* be the first internal call! No other call is
156      * allowed before the thread system has been initialized. */
157     if (vlc_threads_init ())
158         return NULL;
159
160     libvlc_global_data_t *p_libvlc_global = vlc_global();
161     /* Now that the thread system is initialized, we don't have much, but
162      * at least we have variables */
163     vlc_mutex_t *lock = var_AcquireMutex( "libvlc" );
164     if( i_instances == 0 )
165     {
166         /* Guess what CPU we have */
167         cpu_flags = CPUCapabilities();
168        /* The module bank will be initialized later */
169         p_libvlc_global->p_module_bank = NULL;
170     }
171
172     /* Allocate a libvlc instance object */
173     p_libvlc = vlc_custom_create( VLC_OBJECT(p_libvlc_global),
174                                   sizeof (*p_libvlc) + sizeof (libvlc_priv_t),
175                                   VLC_OBJECT_LIBVLC, "libvlc" );
176     if( p_libvlc != NULL )
177         i_instances++;
178     vlc_mutex_unlock( lock );
179
180     if( p_libvlc == NULL )
181         return NULL;
182
183     priv = libvlc_priv (p_libvlc);
184     priv->p_playlist = NULL;
185     priv->p_interaction = NULL;
186     priv->p_vlm = NULL;
187     p_libvlc->psz_object_name = strdup( "libvlc" );
188
189     /* Initialize message queue */
190     msg_Create( p_libvlc );
191
192     /* Find verbosity from VLC_VERBOSE environment variable */
193     psz_env = getenv( "VLC_VERBOSE" );
194     if( psz_env != NULL )
195         priv->i_verbose = atoi( psz_env );
196     else
197         priv->i_verbose = 3;
198 #if defined( HAVE_ISATTY ) && !defined( WIN32 )
199     priv->b_color = isatty( 2 ); /* 2 is for stderr */
200 #else
201     priv->b_color = false;
202 #endif
203
204     /* Announce who we are - Do it only for first instance ? */
205     msg_Dbg( p_libvlc, COPYRIGHT_MESSAGE );
206     msg_Dbg( p_libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
207
208     /* Initialize mutexes */
209     vlc_mutex_init( &priv->timer_lock );
210     vlc_mutex_init( &priv->config_lock );
211 #ifdef __APPLE__
212     vlc_thread_set_priority( p_libvlc, VLC_THREAD_PRIORITY_LOW );
213 #endif
214     /* Store data for the non-reentrant API */
215     p_static_vlc = p_libvlc;
216
217     return p_libvlc;
218 }
219
220 /**
221  * Initialize a libvlc instance
222  * This function initializes a previously allocated libvlc instance:
223  *  - CPU detection
224  *  - gettext initialization
225  *  - message queue, module bank and playlist initialization
226  *  - configuration and commandline parsing
227  */
228 int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc,
229                          const char *ppsz_argv[] )
230 {
231     libvlc_global_data_t *p_libvlc_global = vlc_global();
232     libvlc_priv_t *priv = libvlc_priv (p_libvlc);
233     char         p_capabilities[200];
234     char *       p_tmp = NULL;
235     char *       psz_modules = NULL;
236     char *       psz_parser = NULL;
237     char *       psz_control = NULL;
238     bool   b_exit = false;
239     int          i_ret = VLC_EEXIT;
240     playlist_t  *p_playlist = NULL;
241     vlc_value_t  val;
242 #if defined( ENABLE_NLS ) \
243      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
244 # if defined (WIN32) || defined (__APPLE__)
245     char *       psz_language;
246 #endif
247 #endif
248
249     /* System specific initialization code */
250     system_Init( p_libvlc, &i_argc, ppsz_argv );
251
252     /* Get the executable name (similar to the basename command) */
253     if( i_argc > 0 && ppsz_argv[0][0] )
254     {
255         free( p_libvlc->psz_object_name );
256
257         const char *psz_exe = strrchr( ppsz_argv[0], '/' );
258         if( psz_exe && *(psz_exe + 1) )
259             p_libvlc->psz_object_name = strdup( psz_exe + 1 );
260         else
261             p_libvlc->psz_object_name = strdup( ppsz_argv[0] );
262     }
263
264     /*
265      * Support for gettext
266      */
267     LoadMessages ();
268
269     /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
270     msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") );
271
272     /* Initialize the module bank and load the configuration of the
273      * main module. We need to do this at this stage to be able to display
274      * a short help if required by the user. (short help == main module
275      * options) */
276     module_InitBank( p_libvlc );
277
278     if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true ) )
279     {
280         module_EndBank( p_libvlc );
281         return VLC_EGENERIC;
282     }
283
284     /* Check for short help option */
285     if( config_GetInt( p_libvlc, "help" ) > 0 )
286     {
287         Help( p_libvlc, "help" );
288         b_exit = true;
289         i_ret = VLC_EEXITSUCCESS;
290     }
291     /* Check for version option */
292     else if( config_GetInt( p_libvlc, "version" ) > 0 )
293     {
294         Version();
295         b_exit = true;
296         i_ret = VLC_EEXITSUCCESS;
297     }
298
299     /* Set the config file stuff */
300     priv->psz_configfile = config_GetCustomConfigFile( p_libvlc );
301
302     /* Check for plugins cache options */
303     if( config_GetInt( p_libvlc, "reset-plugins-cache" ) > 0 )
304     {
305         p_libvlc_global->p_module_bank->b_cache_delete = true;
306     }
307
308     /* Will be re-done properly later on */
309     priv->i_verbose = config_GetInt( p_libvlc, "verbose" );
310
311     /* Check for daemon mode */
312 #ifndef WIN32
313     if( config_GetInt( p_libvlc, "daemon" ) > 0 )
314     {
315 #ifdef HAVE_DAEMON
316         char *psz_pidfile = NULL;
317
318         if( daemon( 1, 0) != 0 )
319         {
320             msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" );
321             b_exit = true;
322         }
323         b_daemon = true;
324
325         /* lets check if we need to write the pidfile */
326         psz_pidfile = config_GetPsz( p_libvlc, "pidfile" );
327         if( psz_pidfile != NULL )
328         {
329             FILE *pidfile;
330             pid_t i_pid = getpid ();
331             msg_Dbg( p_libvlc, "PID is %d, writing it to %s",
332                                i_pid, psz_pidfile );
333             pidfile = utf8_fopen( psz_pidfile,"w" );
334             if( pidfile != NULL )
335             {
336                 utf8_fprintf( pidfile, "%d", (int)i_pid );
337                 fclose( pidfile );
338             }
339             else
340             {
341                 msg_Err( p_libvlc, "cannot open pid file for writing: %s (%m)",
342                          psz_pidfile );
343             }
344         }
345         free( psz_pidfile );
346
347 #else
348         pid_t i_pid;
349
350         if( ( i_pid = fork() ) < 0 )
351         {
352             msg_Err( p_libvlc, "unable to fork vlc to daemon mode" );
353             b_exit = true;
354         }
355         else if( i_pid )
356         {
357             /* This is the parent, exit right now */
358             msg_Dbg( p_libvlc, "closing parent process" );
359             b_exit = true;
360             i_ret = VLC_EEXITSUCCESS;
361         }
362         else
363         {
364             /* We are the child */
365             msg_Dbg( p_libvlc, "daemon spawned" );
366             close( STDIN_FILENO );
367             close( STDOUT_FILENO );
368             close( STDERR_FILENO );
369
370             b_daemon = true;
371         }
372 #endif
373     }
374 #endif
375
376     if( b_exit )
377     {
378         module_EndBank( p_libvlc );
379         return i_ret;
380     }
381
382     /* Check for translation config option */
383 #if defined( ENABLE_NLS ) \
384      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
385 # if defined (WIN32) || defined (__APPLE__)
386     /* This ain't really nice to have to reload the config here but it seems
387      * the only way to do it. */
388
389     if( !config_GetInt( p_libvlc, "ignore-config" ) )
390         config_LoadConfigFile( p_libvlc, "main" );
391     config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true );
392
393     /* Check if the user specified a custom language */
394     psz_language = config_GetPsz( p_libvlc, "language" );
395     if( psz_language && *psz_language && strcmp( psz_language, "auto" ) )
396     {
397         bool b_cache_delete = p_libvlc_global->p_module_bank->b_cache_delete;
398
399         /* Reset the default domain */
400         SetLanguage( psz_language );
401
402         /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
403         msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") );
404
405         module_EndBank( p_libvlc );
406         module_InitBank( p_libvlc );
407         if( !config_GetInt( p_libvlc, "ignore-config" ) )
408             config_LoadConfigFile( p_libvlc, "main" );
409         config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true );
410         p_libvlc_global->p_module_bank->b_cache_delete = b_cache_delete;
411     }
412     free( psz_language );
413 # endif
414 #endif
415
416     /*
417      * Load the builtins and plugins into the module_bank.
418      * We have to do it before config_Load*() because this also gets the
419      * list of configuration options exported by each module and loads their
420      * default values.
421      */
422     module_LoadBuiltins( p_libvlc );
423     module_LoadPlugins( p_libvlc );
424     if( p_libvlc->b_die )
425     {
426         b_exit = true;
427     }
428
429     msg_Dbg( p_libvlc, "module bank initialized, found %i modules",
430              vlc_internals( p_libvlc_global->p_module_bank )->i_children );
431
432     /* Check for help on modules */
433     if( (p_tmp = config_GetPsz( p_libvlc, "module" )) )
434     {
435         Help( p_libvlc, p_tmp );
436         free( p_tmp );
437         b_exit = true;
438         i_ret = VLC_EEXITSUCCESS;
439     }
440     /* Check for long help option */
441     else if( config_GetInt( p_libvlc, "longhelp" ) > 0 )
442     {
443         Help( p_libvlc, "longhelp" );
444         b_exit = true;
445         i_ret = VLC_EEXITSUCCESS;
446     }
447     /* Check for module list option */
448     else if( config_GetInt( p_libvlc, "list" ) > 0 )
449     {
450         ListModules( p_libvlc, false );
451         b_exit = true;
452         i_ret = VLC_EEXITSUCCESS;
453     }
454     else if( config_GetInt( p_libvlc, "list-verbose" ) > 0 )
455     {
456         ListModules( p_libvlc, true );
457         b_exit = true;
458         i_ret = VLC_EEXITSUCCESS;
459     }
460
461     /* Check for config file options */
462     if( !config_GetInt( p_libvlc, "ignore-config" ) )
463     {
464         if( config_GetInt( p_libvlc, "reset-config" ) > 0 )
465         {
466             config_ResetAll( p_libvlc );
467             config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true );
468             config_SaveConfigFile( p_libvlc, NULL );
469         }
470         if( config_GetInt( p_libvlc, "save-config" ) > 0 )
471         {
472             config_LoadConfigFile( p_libvlc, NULL );
473             config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true );
474             config_SaveConfigFile( p_libvlc, NULL );
475         }
476     }
477
478     if( b_exit )
479     {
480         module_EndBank( p_libvlc );
481         return i_ret;
482     }
483
484     /*
485      * Init device values
486      */
487     InitDeviceValues( p_libvlc );
488
489     /*
490      * Override default configuration with config file settings
491      */
492     if( !config_GetInt( p_libvlc, "ignore-config" ) )
493         config_LoadConfigFile( p_libvlc, NULL );
494
495     /*
496      * Override configuration with command line settings
497      */
498     if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, false ) )
499     {
500 #ifdef WIN32
501         ShowConsole( false );
502         /* Pause the console because it's destroyed when we exit */
503         fprintf( stderr, "The command line options couldn't be loaded, check "
504                  "that they are valid.\n" );
505         PauseConsole();
506 #endif
507         module_EndBank( p_libvlc );
508         return VLC_EGENERIC;
509     }
510
511     /*
512      * System specific configuration
513      */
514     system_Configure( p_libvlc, &i_argc, ppsz_argv );
515
516 /* FIXME: could be replaced by using Unix sockets */
517 #ifdef HAVE_DBUS_3
518     dbus_threads_init_default();
519
520     if( config_GetInt( p_libvlc, "one-instance" ) > 0 )
521     {
522         /* Initialise D-Bus interface, check for other instances */
523         DBusConnection  *p_conn = NULL;
524         DBusError       dbus_error;
525
526         dbus_error_init( &dbus_error );
527
528         /* connect to the session bus */
529         p_conn = dbus_bus_get( DBUS_BUS_SESSION, &dbus_error );
530         if( !p_conn )
531         {
532             msg_Err( p_libvlc, "Failed to connect to D-Bus session daemon: %s",
533                     dbus_error.message );
534             dbus_error_free( &dbus_error );
535         }
536         else
537         {
538             /* check if VLC is available on the bus
539              * if not: D-Bus control is not enabled on the other
540              * instance and we can't pass MRLs to it */
541             DBusMessage *p_test_msg = NULL;
542             DBusMessage *p_test_reply = NULL;
543             p_test_msg =  dbus_message_new_method_call(
544                     "org.mpris.vlc", "/",
545                     "org.freedesktop.MediaPlayer", "Identity" );
546             /* block until a reply arrives */
547             p_test_reply = dbus_connection_send_with_reply_and_block(
548                     p_conn, p_test_msg, -1, &dbus_error );
549             dbus_message_unref( p_test_msg );
550             if( p_test_reply == NULL )
551             {
552                 dbus_error_free( &dbus_error );
553                 msg_Dbg( p_libvlc, "No Media Player is running. "
554                         "Continuing normally." );
555             }
556             else
557             {
558                 int i_input;
559                 DBusMessage* p_dbus_msg = NULL;
560                 DBusMessageIter dbus_args;
561                 DBusPendingCall* p_dbus_pending = NULL;
562                 dbus_bool_t b_play;
563
564                 dbus_message_unref( p_test_reply );
565                 msg_Warn( p_libvlc, "Another Media Player is running. Exiting");
566
567                 for( i_input = optind;i_input < i_argc;i_input++ )
568                 {
569                     msg_Dbg( p_libvlc, "Adds %s to the running Media Player",
570                             ppsz_argv[i_input] );
571
572                     p_dbus_msg = dbus_message_new_method_call(
573                             "org.mpris.vlc", "/TrackList",
574                             "org.freedesktop.MediaPlayer", "AddTrack" );
575
576                     if ( NULL == p_dbus_msg )
577                     {
578                         msg_Err( p_libvlc, "D-Bus problem" );
579                         system_End( p_libvlc );
580                         exit( VLC_ETIMEOUT );
581                     }
582
583                     /* append MRLs */
584                     dbus_message_iter_init_append( p_dbus_msg, &dbus_args );
585                     if ( !dbus_message_iter_append_basic( &dbus_args,
586                                 DBUS_TYPE_STRING, &ppsz_argv[i_input] ) )
587                     {
588                         msg_Err( p_libvlc, "Out of memory" );
589                         dbus_message_unref( p_dbus_msg );
590                         system_End( p_libvlc );
591                         exit( VLC_ENOMEM );
592                     }
593                     b_play = TRUE;
594                     if( config_GetInt( p_libvlc, "playlist-enqueue" ) > 0 )
595                         b_play = FALSE;
596                     if ( !dbus_message_iter_append_basic( &dbus_args,
597                                 DBUS_TYPE_BOOLEAN, &b_play ) )
598                     {
599                         msg_Err( p_libvlc, "Out of memory" );
600                         dbus_message_unref( p_dbus_msg );
601                         system_End( p_libvlc );
602                         exit( VLC_ENOMEM );
603                     }
604
605                     /* send message and get a handle for a reply */
606                     if ( !dbus_connection_send_with_reply ( p_conn,
607                                 p_dbus_msg, &p_dbus_pending, -1 ) )
608                     {
609                         msg_Err( p_libvlc, "D-Bus problem" );
610                         dbus_message_unref( p_dbus_msg );
611                         system_End( p_libvlc );
612                         exit( VLC_ETIMEOUT );
613                     }
614
615                     if ( NULL == p_dbus_pending )
616                     {
617                         msg_Err( p_libvlc, "D-Bus problem" );
618                         dbus_message_unref( p_dbus_msg );
619                         system_End( p_libvlc );
620                         exit( VLC_ETIMEOUT );
621                     }
622                     dbus_connection_flush( p_conn );
623                     dbus_message_unref( p_dbus_msg );
624                     /* block until we receive a reply */
625                     dbus_pending_call_block( p_dbus_pending );
626                     dbus_pending_call_unref( p_dbus_pending );
627                 } /* processes all command line MRLs */
628
629                 /* bye bye */
630                 system_End( p_libvlc );
631                 exit( VLC_SUCCESS );
632             }
633         }
634         /* we unreference the connection when we've finished with it */
635         if( p_conn ) dbus_connection_unref( p_conn );
636     }
637 #endif
638
639     /*
640      * Message queue options
641      */
642
643     var_Create( p_libvlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
644     if( config_GetInt( p_libvlc, "quiet" ) > 0 )
645     {
646         val.i_int = -1;
647         var_Set( p_libvlc, "verbose", val );
648     }
649     var_AddCallback( p_libvlc, "verbose", VerboseCallback, NULL );
650     var_Change( p_libvlc, "verbose", VLC_VAR_TRIGGER_CALLBACKS, NULL, NULL );
651
652     if( priv->b_color )
653         priv->b_color = config_GetInt( p_libvlc, "color" ) > 0;
654
655     /*
656      * Output messages that may still be in the queue
657      */
658     msg_Flush( p_libvlc );
659
660     if( !config_GetInt( p_libvlc, "fpu" ) )
661         cpu_flags &= ~CPU_CAPABILITY_FPU;
662
663 #if defined( __i386__ ) || defined( __x86_64__ )
664     if( !config_GetInt( p_libvlc, "mmx" ) )
665         cpu_flags &= ~CPU_CAPABILITY_MMX;
666     if( !config_GetInt( p_libvlc, "3dn" ) )
667         cpu_flags &= ~CPU_CAPABILITY_3DNOW;
668     if( !config_GetInt( p_libvlc, "mmxext" ) )
669         cpu_flags &= ~CPU_CAPABILITY_MMXEXT;
670     if( !config_GetInt( p_libvlc, "sse" ) )
671         cpu_flags &= ~CPU_CAPABILITY_SSE;
672     if( !config_GetInt( p_libvlc, "sse2" ) )
673         cpu_flags &= ~CPU_CAPABILITY_SSE2;
674 #endif
675 #if defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
676     if( !config_GetInt( p_libvlc, "altivec" ) )
677         cpu_flags &= ~CPU_CAPABILITY_ALTIVEC;
678 #endif
679
680 #define PRINT_CAPABILITY( capability, string )                              \
681     if( vlc_CPU() & capability )                                            \
682     {                                                                       \
683         strncat( p_capabilities, string " ",                                \
684                  sizeof(p_capabilities) - strlen(p_capabilities) );         \
685         p_capabilities[sizeof(p_capabilities) - 1] = '\0';                  \
686     }
687
688     p_capabilities[0] = '\0';
689     PRINT_CAPABILITY( CPU_CAPABILITY_486, "486" );
690     PRINT_CAPABILITY( CPU_CAPABILITY_586, "586" );
691     PRINT_CAPABILITY( CPU_CAPABILITY_PPRO, "Pentium Pro" );
692     PRINT_CAPABILITY( CPU_CAPABILITY_MMX, "MMX" );
693     PRINT_CAPABILITY( CPU_CAPABILITY_3DNOW, "3DNow!" );
694     PRINT_CAPABILITY( CPU_CAPABILITY_MMXEXT, "MMXEXT" );
695     PRINT_CAPABILITY( CPU_CAPABILITY_SSE, "SSE" );
696     PRINT_CAPABILITY( CPU_CAPABILITY_SSE2, "SSE2" );
697     PRINT_CAPABILITY( CPU_CAPABILITY_ALTIVEC, "AltiVec" );
698     PRINT_CAPABILITY( CPU_CAPABILITY_FPU, "FPU" );
699     msg_Dbg( p_libvlc, "CPU has capabilities %s", p_capabilities );
700
701     /*
702      * Choose the best memcpy module
703      */
704     priv->p_memcpy_module = module_Need( p_libvlc, "memcpy", "$memcpy", 0 );
705
706     priv->b_stats = config_GetInt( p_libvlc, "stats" ) > 0;
707     priv->i_timers = 0;
708     priv->pp_timers = NULL;
709
710     /* Init stats */
711     p_libvlc->p_stats = (global_stats_t *)malloc( sizeof( global_stats_t ) );
712     if( !p_libvlc->p_stats )
713     {
714         vlc_object_release( p_libvlc );
715         return VLC_ENOMEM;
716     }
717     vlc_mutex_init( &p_libvlc->p_stats->lock );
718     priv->p_stats_computer = NULL;
719
720     /* Init the array that holds every input item */
721     ARRAY_INIT( priv->input_items );
722     priv->i_last_input_id = 0;
723
724     /*
725      * Initialize hotkey handling
726      */
727     var_Create( p_libvlc, "key-pressed", VLC_VAR_INTEGER );
728     var_Create( p_libvlc, "key-action", VLC_VAR_INTEGER );
729     p_libvlc->p_hotkeys = malloc( libvlc_hotkeys_size );
730     /* Do a copy (we don't need to modify the strings) */
731     memcpy( p_libvlc->p_hotkeys, libvlc_hotkeys, libvlc_hotkeys_size );
732     var_AddCallback( p_libvlc, "key-pressed", vlc_key_to_action,
733                      p_libvlc->p_hotkeys );
734
735     /* Initialize interaction */
736     priv->p_interaction = interaction_Init( p_libvlc );
737
738     /* Initialize playlist and get commandline files */
739     playlist_ThreadCreate( p_libvlc );
740     if( !priv->p_playlist )
741     {
742         msg_Err( p_libvlc, "playlist initialization failed" );
743         if( priv->p_memcpy_module != NULL )
744         {
745             module_Unneed( p_libvlc, priv->p_memcpy_module );
746         }
747         module_EndBank( p_libvlc );
748         return VLC_EGENERIC;
749     }
750     p_playlist = priv->p_playlist;
751
752     psz_modules = config_GetPsz( p_playlist, "services-discovery" );
753     if( psz_modules && *psz_modules )
754     {
755         /* Add service discovery modules */
756         playlist_ServicesDiscoveryAdd( p_playlist, psz_modules );
757     }
758     free( psz_modules );
759
760 #ifdef ENABLE_SOUT
761     /* Initialize VLM if vlm-conf is specified */
762     psz_parser = config_GetPsz( p_libvlc, "vlm-conf" );
763     if( psz_parser && *psz_parser )
764     {
765         priv->p_vlm = vlm_New( p_libvlc );
766         if( !priv->p_vlm )
767             msg_Err( p_libvlc, "VLM initialization failed" );
768     }
769     free( psz_parser );
770 #endif
771
772     /*
773      * Load background interfaces
774      */
775     psz_modules = config_GetPsz( p_libvlc, "extraintf" );
776     psz_control = config_GetPsz( p_libvlc, "control" );
777
778     if( psz_modules && *psz_modules && psz_control && *psz_control )
779     {
780         psz_modules = (char *)realloc( psz_modules, strlen( psz_modules ) +
781                                                     strlen( psz_control ) + 1 );
782         sprintf( psz_modules, "%s:%s", psz_modules, psz_control );
783     }
784     else if( psz_control && *psz_control )
785     {
786         free( psz_modules );
787         psz_modules = strdup( psz_control );
788     }
789
790     psz_parser = psz_modules;
791     while ( psz_parser && *psz_parser )
792     {
793         char *psz_module, *psz_temp;
794         psz_module = psz_parser;
795         psz_parser = strchr( psz_module, ':' );
796         if ( psz_parser )
797         {
798             *psz_parser = '\0';
799             psz_parser++;
800         }
801         psz_temp = (char *)malloc( strlen(psz_module) + sizeof(",none") );
802         if( psz_temp )
803         {
804             sprintf( psz_temp, "%s,none", psz_module );
805             libvlc_InternalAddIntf( p_libvlc, psz_temp, false, false, 0, NULL );
806             free( psz_temp );
807         }
808     }
809     free( psz_modules );
810     free( psz_control );
811
812     /*
813      * Always load the hotkeys interface if it exists
814      */
815     libvlc_InternalAddIntf( p_libvlc, "hotkeys,none", false, false, 0, NULL );
816
817 #ifdef HAVE_DBUS_3
818     /* loads dbus control interface if in one-instance mode
819      * we do it only when playlist exists, because dbus module needs it */
820     if( config_GetInt( p_libvlc, "one-instance" ) > 0 )
821         libvlc_InternalAddIntf( p_libvlc, "dbus,none", false, false, 0, NULL );
822
823     /* Prevents the power management daemon from suspending the system
824      * when VLC is active */
825     if( config_GetInt( p_libvlc, "inhibit" ) > 0 )
826         libvlc_InternalAddIntf( p_libvlc, "inhibit,none", false, false, 0, NULL );
827 #endif
828
829     /*
830      * If needed, load the Xscreensaver interface
831      * Currently, only for X
832      */
833 #ifdef HAVE_X11_XLIB_H
834     if( config_GetInt( p_libvlc, "disable-screensaver" ) )
835     {
836         libvlc_InternalAddIntf( p_libvlc, "screensaver,none", false, false, 0, NULL );
837     }
838 #endif
839
840     if( config_GetInt( p_libvlc, "file-logging" ) > 0 )
841     {
842         libvlc_InternalAddIntf( p_libvlc, "logger,none", false, false, 0, NULL );
843     }
844 #ifdef HAVE_SYSLOG_H
845     if( config_GetInt( p_libvlc, "syslog" ) > 0 )
846     {
847         const char *psz_logmode = "logmode=syslog";
848         libvlc_InternalAddIntf( p_libvlc, "logger,none", false, false,
849                                 1, &psz_logmode );
850     }
851 #endif
852
853     if( config_GetInt( p_libvlc, "show-intf" ) > 0 )
854     {
855         libvlc_InternalAddIntf( p_libvlc, "showintf,none", false, false, 0, NULL );
856     }
857
858     if( config_GetInt( p_libvlc, "network-synchronisation") > 0 )
859     {
860         libvlc_InternalAddIntf( p_libvlc, "netsync,none", false, false, 0, NULL );
861     }
862
863 #ifdef WIN32
864     if( config_GetInt( p_libvlc, "prefer-system-codecs") > 0 )
865     {
866         char *psz_codecs = config_GetPsz( p_playlist, "codec" );
867         if( psz_codecs )
868         {
869             char *psz_morecodecs;
870             asprintf(&psz_morecodecs, "%s,dmo,quicktime", psz_codecs);
871             if( psz_morecodecs )
872             {
873                 config_PutPsz( p_libvlc, "codec", psz_morecodecs);
874                 free( psz_morecodecs );
875             }
876         }
877         else
878             config_PutPsz( p_libvlc, "codec", "dmo,quicktime");
879         free( psz_codecs );
880     }
881 #endif
882
883     /*
884      * FIXME: kludge to use a p_libvlc-local variable for the Mozilla plugin
885      */
886     var_Create( p_libvlc, "drawable", VLC_VAR_INTEGER );
887     var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER );
888     var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER );
889     var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER );
890     var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER );
891     var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER );
892     var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER );
893     var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER );
894     var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER );
895
896     /* Create volume callback system. */
897     var_Create( p_libvlc, "volume-change", VLC_VAR_BOOL );
898
899     /*
900      * Get input filenames given as commandline arguments
901      */
902     GetFilenames( p_libvlc, i_argc, ppsz_argv );
903
904     /*
905      * Get --open argument
906      */
907     var_Create( p_libvlc, "open", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
908     var_Get( p_libvlc, "open", &val );
909     if ( val.psz_string != NULL && *val.psz_string )
910     {
911         VLC_AddTarget( p_libvlc->i_object_id, val.psz_string, NULL, 0,
912                        PLAYLIST_INSERT, 0 );
913     }
914     free( val.psz_string );
915
916     return VLC_SUCCESS;
917 }
918
919 /**
920  * Cleanup a libvlc instance. The instance is not completely deallocated
921  * \param p_libvlc the instance to clean
922  */
923 int libvlc_InternalCleanup( libvlc_int_t *p_libvlc )
924 {
925     intf_thread_t      * p_intf = NULL;
926     vout_thread_t      * p_vout = NULL;
927     libvlc_priv_t      *priv = libvlc_priv (p_libvlc);
928
929     /* Ask the interfaces to stop and destroy them */
930     msg_Dbg( p_libvlc, "removing all interfaces" );
931     while( (p_intf = vlc_object_find( p_libvlc, VLC_OBJECT_INTF, FIND_CHILD )) )
932     {
933         intf_StopThread( p_intf );
934         vlc_object_detach( p_intf );
935         vlc_object_release( p_intf );
936         intf_Destroy( p_intf );
937         p_intf = NULL;
938     }
939
940     /* Free video outputs */
941     msg_Dbg( p_libvlc, "removing all video outputs" );
942     while( (p_vout = vlc_object_find( p_libvlc, VLC_OBJECT_VOUT, FIND_CHILD )) )
943     {
944         vlc_object_detach( p_vout );
945         vlc_object_release( p_vout );
946         vout_Destroy( p_vout );
947     }
948
949 #ifdef ENABLE_SOUT
950     playlist_t         * p_playlist;
951     sout_instance_t    * p_sout;
952
953     p_playlist = vlc_object_find( p_libvlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
954     if( p_playlist )
955     {
956         p_sout = vlc_object_find( p_playlist, VLC_OBJECT_SOUT, FIND_CHILD );
957         if( p_sout )
958         {
959             msg_Dbg( p_sout, "removing kept stream output" );
960             vlc_object_detach( (vlc_object_t*)p_sout );
961             vlc_object_release( (vlc_object_t*)p_sout );
962             sout_DeleteInstance( p_sout );
963         }
964
965         vlc_object_release( p_playlist );
966     }
967
968     /* Destroy VLM if created in libvlc_InternalInit */
969     if( priv->p_vlm )
970     {
971         vlm_Delete( priv->p_vlm );
972     }
973 #endif
974
975     /* Free playlist */
976     msg_Dbg( p_libvlc, "removing playlist" );
977     vlc_object_release( priv->p_playlist );
978
979     /* Free interaction */
980     msg_Dbg( p_libvlc, "removing interaction" );
981     vlc_object_release( priv->p_interaction );
982
983     stats_TimersDumpAll( p_libvlc );
984     stats_TimersCleanAll( p_libvlc );
985
986 #ifdef ENABLE_SOUT
987     announce_handler_t * p_announce;
988
989     /* Free announce handler(s?) */
990     while( (p_announce = vlc_object_find( p_libvlc, VLC_OBJECT_ANNOUNCE,
991                                                  FIND_CHILD ) ) )
992     {
993         msg_Dbg( p_libvlc, "removing announce handler" );
994         vlc_object_detach( p_announce );
995         vlc_object_release( p_announce );
996         announce_HandlerDestroy( p_announce );
997     }
998 #endif
999
1000     bool b_clean = true;
1001     FOREACH_ARRAY( input_item_t *p_del, priv->input_items )
1002         msg_Err( p_libvlc, "input item %p has not been deleted properly: refcount %d, name %s",
1003             p_del, p_del->i_gc_refcount, p_del->psz_name ? p_del->psz_name : "(null)" );
1004         b_clean = false;
1005     FOREACH_END();
1006     assert( b_clean );
1007     ARRAY_RESET( priv->input_items );
1008
1009     msg_Dbg( p_libvlc, "removing stats" );
1010     vlc_mutex_destroy( &p_libvlc->p_stats->lock );
1011     FREENULL( p_libvlc->p_stats );
1012
1013     return VLC_SUCCESS;
1014 }
1015
1016 /**
1017  * Destroy everything.
1018  * This function requests the running threads to finish, waits for their
1019  * termination, and destroys their structure.
1020  * It stops the thread systems: no instance can run after this has run
1021  * \param p_libvlc the instance to destroy
1022  * \param b_release whether we should do a release on the instance
1023  */
1024 int libvlc_InternalDestroy( libvlc_int_t *p_libvlc, bool b_release )
1025 {
1026     if( !p_libvlc )
1027         return VLC_EGENERIC;
1028
1029     libvlc_priv_t *priv = libvlc_priv (p_libvlc);
1030
1031 #ifndef WIN32
1032     char* psz_pidfile = NULL;
1033
1034     if( b_daemon )
1035     {
1036         psz_pidfile = config_GetPsz( p_libvlc, "pidfile" );
1037         if( psz_pidfile != NULL )
1038         {
1039             msg_Dbg( p_libvlc, "removing pid file %s", psz_pidfile );
1040             if( unlink( psz_pidfile ) == -1 )
1041             {
1042                 msg_Dbg( p_libvlc, "removing pid file %s: %m",
1043                         psz_pidfile );
1044             }
1045         }
1046         free( psz_pidfile );
1047     }
1048 #endif
1049
1050     if( priv->p_memcpy_module )
1051     {
1052         module_Unneed( p_libvlc, priv->p_memcpy_module );
1053         priv->p_memcpy_module = NULL;
1054     }
1055
1056     /* Free module bank. It is refcounted, so we call this each time  */
1057     module_EndBank( p_libvlc );
1058
1059     FREENULL( priv->psz_configfile );
1060     var_DelCallback( p_libvlc, "key-pressed", vlc_key_to_action,
1061                      p_libvlc->p_hotkeys );
1062     FREENULL( p_libvlc->p_hotkeys );
1063
1064     vlc_mutex_t *lock = var_AcquireMutex( "libvlc" );
1065     i_instances--;
1066
1067     if( i_instances == 0 )
1068     {
1069         /* System specific cleaning code */
1070         system_End( p_libvlc );
1071     }
1072     vlc_mutex_unlock( lock );
1073
1074     msg_Flush( p_libvlc );
1075     msg_Destroy( p_libvlc );
1076
1077     /* Destroy mutexes */
1078     vlc_mutex_destroy( &priv->config_lock );
1079     vlc_mutex_destroy( &priv->timer_lock );
1080
1081     if( b_release ) vlc_object_release( p_libvlc );
1082     vlc_object_release( p_libvlc );
1083     p_libvlc = NULL;
1084
1085     /* Stop thread system: last one out please shut the door!
1086      * The number of initializations of the thread system is counted, we
1087      * can call this each time */
1088     vlc_threads_end ();
1089
1090     return VLC_SUCCESS;
1091 }
1092
1093 /**
1094  * Add an interface plugin and run it
1095  */
1096 int libvlc_InternalAddIntf( libvlc_int_t *p_libvlc,
1097                             char const *psz_module,
1098                             bool b_block, bool b_play,
1099                             int i_options, const char *const *ppsz_options )
1100 {
1101     int i_err;
1102     intf_thread_t *p_intf = NULL;
1103
1104     if( !p_libvlc )
1105         return VLC_EGENERIC;
1106
1107     if( !psz_module ) /* requesting the default interface */
1108     {
1109         char *psz_interface = config_GetPsz( p_libvlc, "intf" );
1110         if( !psz_interface || !*psz_interface ) /* "intf" has not been set */
1111             msg_Info( p_libvlc, _("Running vlc with the default interface. Use 'cvlc' to use vlc without interface.") );
1112         free( psz_interface );
1113     }
1114
1115 #ifndef WIN32
1116     if( b_daemon && b_block && !psz_module )
1117     {
1118         /* Daemon mode hack.
1119          * We prefer the dummy interface if none is specified. */
1120         char *psz_interface = config_GetPsz( p_libvlc, "intf" );
1121         if( !psz_interface || !*psz_interface ) psz_module = "dummy";
1122         free( psz_interface );
1123     }
1124 #endif
1125
1126     /* Try to create the interface */
1127     p_intf = intf_Create( p_libvlc, psz_module ? psz_module : "$intf",
1128                           i_options, ppsz_options );
1129     if( p_intf == NULL )
1130     {
1131         msg_Err( p_libvlc, "interface \"%s\" initialization failed",
1132                  psz_module );
1133         return VLC_EGENERIC;
1134     }
1135
1136     /* Interface doesn't handle play on start so do it ourselves */
1137     if( !p_intf->b_play && b_play )
1138         playlist_Play( libvlc_priv(p_libvlc)->p_playlist );
1139
1140     /* Try to run the interface */
1141     p_intf->b_play = b_play;
1142     i_err = intf_RunThread( p_intf );
1143     if( i_err || p_intf->b_should_run_on_first_thread )
1144     {
1145         vlc_object_detach( p_intf );
1146         intf_Destroy( p_intf );
1147         p_intf = NULL;
1148         return i_err;
1149     }
1150
1151     if( b_block )
1152     {
1153         /* FIXME: should be moved to interface/interface.c */
1154         if( p_intf->pf_run )
1155             vlc_thread_join( p_intf );
1156         else
1157             while( vlc_object_lock_and_wait( p_intf ) == 0 );
1158
1159         vlc_object_detach( p_intf );
1160         intf_Destroy( p_intf );
1161     }
1162
1163     return VLC_SUCCESS;
1164 };
1165
1166 #if defined( ENABLE_NLS ) && (defined (__APPLE__) || defined (WIN32)) && \
1167     ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
1168 /*****************************************************************************
1169  * SetLanguage: set the interface language.
1170  *****************************************************************************
1171  * We set the LC_MESSAGES locale category for interface messages and buttons,
1172  * as well as the LC_CTYPE category for string sorting and possible wide
1173  * character support.
1174  *****************************************************************************/
1175 static void SetLanguage ( const char *psz_lang )
1176 {
1177 #ifdef __APPLE__
1178     /* I need that under Darwin, please check it doesn't disturb
1179      * other platforms. --Meuuh */
1180     setenv( "LANG", psz_lang, 1 );
1181
1182 #else
1183     /* We set LC_ALL manually because it is the only way to set
1184      * the language at runtime under eg. Windows. Beware that this
1185      * makes the environment unconsistent when libvlc is unloaded and
1186      * should probably be moved to a safer place like vlc.c. */
1187     static char psz_lcall[20];
1188     snprintf( psz_lcall, 19, "LC_ALL=%s", psz_lang );
1189     psz_lcall[19] = '\0';
1190     putenv( psz_lcall );
1191 #endif
1192
1193     setlocale( LC_ALL, psz_lang );
1194 }
1195 #endif
1196
1197
1198 static inline int LoadMessages (void)
1199 {
1200 #if defined( ENABLE_NLS ) \
1201      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
1202     /* Specify where to find the locales for current domain */
1203 #if !defined( __APPLE__ ) && !defined( WIN32 ) && !defined( SYS_BEOS )
1204     static const char psz_path[] = LOCALEDIR;
1205 #else
1206     char psz_path[1024];
1207     if (snprintf (psz_path, sizeof (psz_path), "%s/%s",
1208                   vlc_global()->psz_vlcpath, "locale")
1209                      >= (int)sizeof (psz_path))
1210         return -1;
1211
1212 #endif
1213     if (bindtextdomain (PACKAGE_NAME, psz_path) == NULL)
1214     {
1215         fprintf (stderr, "Warning: cannot bind text domain "PACKAGE_NAME
1216                          " to directory %s\n", psz_path);
1217         return -1;
1218     }
1219
1220     /* LibVLC wants all messages in UTF-8.
1221      * Unfortunately, we cannot ask UTF-8 for strerror_r(), strsignal_r()
1222      * and other functions that are not part of our text domain.
1223      */
1224     if (bind_textdomain_codeset (PACKAGE_NAME, "UTF-8") == NULL)
1225     {
1226         fprintf (stderr, "Error: cannot set Unicode encoding for text domain "
1227                          PACKAGE_NAME"\n");
1228         // Unbinds the text domain to avoid broken encoding
1229         bindtextdomain (PACKAGE_NAME, "DOES_NOT_EXIST");
1230         return -1;
1231     }
1232
1233     /* LibVLC does NOT set the default textdomain, since it is a library.
1234      * This could otherwise break programs using LibVLC (other than VLC).
1235      * textdomain (PACKAGE_NAME);
1236      */
1237 #endif
1238     return 0;
1239 }
1240
1241 /*****************************************************************************
1242  * GetFilenames: parse command line options which are not flags
1243  *****************************************************************************
1244  * Parse command line for input files as well as their associated options.
1245  * An option always follows its associated input and begins with a ":".
1246  *****************************************************************************/
1247 static int GetFilenames( libvlc_int_t *p_vlc, int i_argc, const char *ppsz_argv[] )
1248 {
1249     int i_opt, i_options;
1250
1251     /* We assume that the remaining parameters are filenames
1252      * and their input options */
1253     for( i_opt = i_argc - 1; i_opt >= optind; i_opt-- )
1254     {
1255         i_options = 0;
1256
1257         /* Count the input options */
1258         while( *ppsz_argv[ i_opt ] == ':' && i_opt > optind )
1259         {
1260             i_options++;
1261             i_opt--;
1262         }
1263
1264         /* TODO: write an internal function of this one, to avoid
1265          *       unnecessary lookups. */
1266
1267         VLC_AddTarget( p_vlc->i_object_id, ppsz_argv[i_opt],
1268                        ( i_options ? &ppsz_argv[i_opt + 1] :
1269                                         NULL ), i_options,
1270                        PLAYLIST_INSERT, 0 );
1271     }
1272
1273     return VLC_SUCCESS;
1274 }
1275
1276 /*****************************************************************************
1277  * Help: print program help
1278  *****************************************************************************
1279  * Print a short inline help. Message interface is initialized at this stage.
1280  *****************************************************************************/
1281 static void Help( libvlc_int_t *p_this, char const *psz_help_name )
1282 {
1283 #ifdef WIN32
1284     ShowConsole( true );
1285 #endif
1286
1287     if( psz_help_name && !strcmp( psz_help_name, "help" ) )
1288     {
1289         utf8_fprintf( stdout, vlc_usage, p_this->psz_object_name );
1290         Usage( p_this, "help" );
1291         Usage( p_this, "main" );
1292     }
1293     else if( psz_help_name && !strcmp( psz_help_name, "longhelp" ) )
1294     {
1295         utf8_fprintf( stdout, vlc_usage, p_this->psz_object_name );
1296         Usage( p_this, NULL );
1297     }
1298     else if( psz_help_name )
1299     {
1300         Usage( p_this, psz_help_name );
1301     }
1302
1303 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
1304     PauseConsole();
1305 #endif
1306 }
1307
1308 /*****************************************************************************
1309  * Usage: print module usage
1310  *****************************************************************************
1311  * Print a short inline help. Message interface is initialized at this stage.
1312  *****************************************************************************/
1313 static void Usage( libvlc_int_t *p_this, char const *psz_module_name )
1314 {
1315 #define FORMAT_STRING "  %s --%s%s%s%s%s%s%s "
1316     /* short option ------'    | | | | | | |
1317      * option name ------------' | | | | | |
1318      * <bra ---------------------' | | | | |
1319      * option type or "" ----------' | | | |
1320      * ket> -------------------------' | | |
1321      * padding spaces -----------------' | |
1322      * comment --------------------------' |
1323      * comment suffix ---------------------'
1324      *
1325      * The purpose of having bra and ket is that we might i18n them as well.
1326      */
1327
1328 #   define COL(x)  "\033[" #x ";1m"
1329 #   define RED     COL(31)
1330 #   define GREEN   COL(32)
1331 #   define YELLOW  COL(33)
1332 #   define BLUE    COL(34)
1333 #   define MAGENTA COL(35)
1334 #   define CYAN    COL(36)
1335 #   define WHITE   COL(0)
1336 #   define GRAY    "\033[0m"
1337 #define COLOR_FORMAT_STRING (WHITE"  %s --%s"YELLOW"%s%s%s%s%s%s "GRAY)
1338 #define COLOR_FORMAT_STRING_BOOL (WHITE"  %s --%s%s%s%s%s%s%s "GRAY)
1339
1340 #define LINE_START 8
1341 #define PADDING_SPACES 25
1342 #ifdef WIN32
1343 #   define OPTION_VALUE_SEP "="
1344 #else
1345 #   define OPTION_VALUE_SEP " "
1346 #endif
1347     vlc_list_t *p_list = NULL;
1348     char psz_spaces_text[PADDING_SPACES+LINE_START+1];
1349     char psz_spaces_longtext[LINE_START+3];
1350     char psz_format[sizeof(COLOR_FORMAT_STRING)];
1351     char psz_format_bool[sizeof(COLOR_FORMAT_STRING_BOOL)];
1352     char psz_buffer[10000];
1353     char psz_short[4];
1354     int i_index;
1355     int i_width = ConsoleWidth() - (PADDING_SPACES+LINE_START+1);
1356     int i_width_description = i_width + PADDING_SPACES - 1;
1357     bool b_advanced    = config_GetInt( p_this, "advanced" ) > 0;
1358     bool b_description = config_GetInt( p_this, "help-verbose" ) > 0;
1359     bool b_description_hack;
1360     bool b_color       = config_GetInt( p_this, "color" ) > 0;
1361     bool b_has_advanced = false;
1362
1363     memset( psz_spaces_text, ' ', PADDING_SPACES+LINE_START );
1364     psz_spaces_text[PADDING_SPACES+LINE_START] = '\0';
1365     memset( psz_spaces_longtext, ' ', LINE_START+2 );
1366     psz_spaces_longtext[LINE_START+2] = '\0';
1367 #ifdef WIN32
1368     b_color = false; // don't put color control codes in a .txt file
1369 #endif
1370
1371     if( b_color )
1372     {
1373         strcpy( psz_format, COLOR_FORMAT_STRING );
1374         strcpy( psz_format_bool, COLOR_FORMAT_STRING_BOOL );
1375     }
1376     else
1377     {
1378         strcpy( psz_format, FORMAT_STRING );
1379         strcpy( psz_format_bool, FORMAT_STRING );
1380     }
1381
1382     /* List all modules */
1383     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1384
1385     /* Ugly hack to make sure that the help options always come first
1386      * (part 1) */
1387     if( !psz_module_name )
1388         Usage( p_this, "help" );
1389
1390     /* Enumerate the config for each module */
1391     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1392     {
1393         bool b_help_module;
1394         module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object;
1395         module_config_t *p_item = NULL;
1396         module_config_t *p_end = p_parser->p_config + p_parser->confsize;
1397
1398         if( psz_module_name && strcmp( psz_module_name,
1399                                        p_parser->psz_object_name ) )
1400         {
1401             const char *const *pp_shortcut = p_parser->pp_shortcuts;
1402             while( *pp_shortcut )
1403             {
1404                 if( !strcmp( psz_module_name, *pp_shortcut ) )
1405                     break;
1406                 pp_shortcut ++;
1407             }
1408             if( !*pp_shortcut )
1409                 continue;
1410         }
1411
1412         /* Ignore modules without config options */
1413         if( !p_parser->i_config_items )
1414         {
1415             continue;
1416         }
1417
1418         b_help_module = !strcmp( "help", p_parser->psz_object_name );
1419         /* Ugly hack to make sure that the help options always come first
1420          * (part 2) */
1421         if( !psz_module_name && b_help_module )
1422             continue;
1423
1424         /* Ignore modules with only advanced config options if requested */
1425         if( !b_advanced )
1426         {
1427             for( p_item = p_parser->p_config;
1428                  p_item < p_end;
1429                  p_item++ )
1430             {
1431                 if( (p_item->i_type & CONFIG_ITEM) &&
1432                     !p_item->b_advanced ) break;
1433             }
1434         }
1435
1436         /* Print name of module */
1437         if( strcmp( "main", p_parser->psz_object_name ) )
1438         {
1439             if( b_color )
1440                 utf8_fprintf( stdout, "\n " GREEN "%s" GRAY "\n",
1441                               p_parser->psz_longname );
1442             else
1443                 utf8_fprintf( stdout, "\n %s\n", p_parser->psz_longname );
1444         }
1445         if( p_parser->psz_help )
1446         {
1447             if( b_color )
1448                 utf8_fprintf( stdout, CYAN" %s\n"GRAY, p_parser->psz_help );
1449             else
1450                 utf8_fprintf( stdout, " %s\n", p_parser->psz_help );
1451         }
1452
1453         /* Print module options */
1454         for( p_item = p_parser->p_config;
1455              p_item < p_end;
1456              p_item++ )
1457         {
1458             char *psz_text, *psz_spaces = psz_spaces_text;
1459             const char *psz_bra = NULL, *psz_type = NULL, *psz_ket = NULL;
1460             const char *psz_suf = "", *psz_prefix = NULL;
1461             signed int i;
1462             size_t i_cur_width;
1463
1464             /* Skip removed options */
1465             if( p_item->b_removed )
1466             {
1467                 continue;
1468             }
1469             /* Skip advanced options if requested */
1470             if( p_item->b_advanced && !b_advanced )
1471             {
1472                 b_has_advanced = true;
1473                 continue;
1474             }
1475
1476             switch( p_item->i_type )
1477             {
1478             case CONFIG_HINT_CATEGORY:
1479             case CONFIG_HINT_USAGE:
1480                 if( !strcmp( "main", p_parser->psz_object_name ) )
1481                 {
1482                     if( b_color )
1483                         utf8_fprintf( stdout, GREEN "\n %s\n" GRAY,
1484                                       p_item->psz_text );
1485                     else
1486                         utf8_fprintf( stdout, "\n %s\n", p_item->psz_text );
1487                 }
1488                 if( b_description && p_item->psz_longtext )
1489                 {
1490                     if( b_color )
1491                         utf8_fprintf( stdout, CYAN " %s\n" GRAY,
1492                                       p_item->psz_longtext );
1493                     else
1494                         utf8_fprintf( stdout, " %s\n", p_item->psz_longtext );
1495                 }
1496                 break;
1497
1498             case CONFIG_HINT_SUBCATEGORY:
1499                 if( strcmp( "main", p_parser->psz_object_name ) )
1500                 break;
1501             case CONFIG_SECTION:
1502                 if( b_color )
1503                 {
1504                     utf8_fprintf( stdout, RED"   %s:\n"GRAY,
1505                                   p_item->psz_text );
1506                     if( b_description && p_item->psz_longtext )
1507                         utf8_fprintf( stdout, MAGENTA"   %s\n"GRAY,
1508                                       p_item->psz_longtext );
1509                 }
1510                 else
1511                 {
1512                     utf8_fprintf( stdout, "   %s:\n", p_item->psz_text );
1513                     if( b_description && p_item->psz_longtext )
1514                         utf8_fprintf( stdout, "   %s\n", p_item->psz_longtext );
1515                 }
1516                 break;
1517
1518             case CONFIG_ITEM_STRING:
1519             case CONFIG_ITEM_FILE:
1520             case CONFIG_ITEM_DIRECTORY:
1521             case CONFIG_ITEM_MODULE: /* We could also have "=<" here */
1522             case CONFIG_ITEM_MODULE_CAT:
1523             case CONFIG_ITEM_MODULE_LIST:
1524             case CONFIG_ITEM_MODULE_LIST_CAT:
1525             case CONFIG_ITEM_FONT:
1526             case CONFIG_ITEM_PASSWORD:
1527                 psz_bra = OPTION_VALUE_SEP "<";
1528                 psz_type = _("string");
1529                 psz_ket = ">";
1530
1531                 if( p_item->ppsz_list )
1532                 {
1533                     psz_bra = OPTION_VALUE_SEP "{";
1534                     psz_type = psz_buffer;
1535                     psz_buffer[0] = '\0';
1536                     for( i = 0; p_item->ppsz_list[i]; i++ )
1537                     {
1538                         if( i ) strcat( psz_buffer, "," );
1539                         strcat( psz_buffer, p_item->ppsz_list[i] );
1540                     }
1541                     psz_ket = "}";
1542                 }
1543                 break;
1544             case CONFIG_ITEM_INTEGER:
1545             case CONFIG_ITEM_KEY: /* FIXME: do something a bit more clever */
1546                 psz_bra = OPTION_VALUE_SEP "<";
1547                 psz_type = _("integer");
1548                 psz_ket = ">";
1549
1550                 if( p_item->min.i || p_item->max.i )
1551                 {
1552                     sprintf( psz_buffer, "%s [%i .. %i]", psz_type,
1553                              p_item->min.i, p_item->max.i );
1554                     psz_type = psz_buffer;
1555                 }
1556
1557                 if( p_item->i_list )
1558                 {
1559                     psz_bra = OPTION_VALUE_SEP "{";
1560                     psz_type = psz_buffer;
1561                     psz_buffer[0] = '\0';
1562                     for( i = 0; p_item->ppsz_list_text[i]; i++ )
1563                     {
1564                         if( i ) strcat( psz_buffer, ", " );
1565                         sprintf( psz_buffer + strlen(psz_buffer), "%i (%s)",
1566                                  p_item->pi_list[i],
1567                                  p_item->ppsz_list_text[i] );
1568                     }
1569                     psz_ket = "}";
1570                 }
1571                 break;
1572             case CONFIG_ITEM_FLOAT:
1573                 psz_bra = OPTION_VALUE_SEP "<";
1574                 psz_type = _("float");
1575                 psz_ket = ">";
1576                 if( p_item->min.f || p_item->max.f )
1577                 {
1578                     sprintf( psz_buffer, "%s [%f .. %f]", psz_type,
1579                              p_item->min.f, p_item->max.f );
1580                     psz_type = psz_buffer;
1581                 }
1582                 break;
1583             case CONFIG_ITEM_BOOL:
1584                 psz_bra = ""; psz_type = ""; psz_ket = "";
1585                 if( !b_help_module )
1586                 {
1587                     psz_suf = p_item->value.i ? _(" (default enabled)") :
1588                                                 _(" (default disabled)");
1589                 }
1590                 break;
1591             }
1592
1593             if( !psz_type )
1594             {
1595                 continue;
1596             }
1597
1598             /* Add short option if any */
1599             if( p_item->i_short )
1600             {
1601                 sprintf( psz_short, "-%c,", p_item->i_short );
1602             }
1603             else
1604             {
1605                 strcpy( psz_short, "   " );
1606             }
1607
1608             i = PADDING_SPACES - strlen( p_item->psz_name )
1609                  - strlen( psz_bra ) - strlen( psz_type )
1610                  - strlen( psz_ket ) - 1;
1611
1612             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
1613             {
1614                 psz_prefix =  ", --no-";
1615                 i -= strlen( p_item->psz_name ) + strlen( psz_prefix );
1616             }
1617
1618             if( i < 0 )
1619             {
1620                 psz_spaces[0] = '\n';
1621                 i = 0;
1622             }
1623             else
1624             {
1625                 psz_spaces[i] = '\0';
1626             }
1627
1628             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
1629             {
1630                 utf8_fprintf( stdout, psz_format_bool, psz_short, 
1631                               p_item->psz_name, psz_prefix, p_item->psz_name,
1632                               psz_bra, psz_type, psz_ket, psz_spaces );
1633             }
1634             else
1635             {
1636                 utf8_fprintf( stdout, psz_format, psz_short, p_item->psz_name,
1637                          "", "", psz_bra, psz_type, psz_ket, psz_spaces );
1638             }
1639
1640             psz_spaces[i] = ' ';
1641
1642             /* We wrap the rest of the output */
1643             sprintf( psz_buffer, "%s%s", p_item->psz_text, psz_suf );
1644             b_description_hack = b_description;
1645
1646  description:
1647             psz_text = psz_buffer;
1648             i_cur_width = b_description && !b_description_hack
1649                           ? i_width_description
1650                           : i_width;
1651             while( *psz_text )
1652             {
1653                 char *psz_parser, *psz_word;
1654                 size_t i_end = strlen( psz_text );
1655
1656                 /* If the remaining text fits in a line, print it. */
1657                 if( i_end <= i_cur_width )
1658                 {
1659                     if( b_color )
1660                     {
1661                         if( !b_description || b_description_hack )
1662                             utf8_fprintf( stdout, BLUE"%s\n"GRAY, psz_text );
1663                         else
1664                             utf8_fprintf( stdout, "%s\n", psz_text );
1665                     }
1666                     else
1667                     {
1668                         utf8_fprintf( stdout, "%s\n", psz_text );
1669                     }
1670                     break;
1671                 }
1672
1673                 /* Otherwise, eat as many words as possible */
1674                 psz_parser = psz_text;
1675                 do
1676                 {
1677                     psz_word = psz_parser;
1678                     psz_parser = strchr( psz_word, ' ' );
1679                     /* If no space was found, we reached the end of the text
1680                      * block; otherwise, we skip the space we just found. */
1681                     psz_parser = psz_parser ? psz_parser + 1
1682                                             : psz_text + i_end;
1683
1684                 } while( (size_t)(psz_parser - psz_text) <= i_cur_width );
1685
1686                 /* We cut a word in one of these cases:
1687                  *  - it's the only word in the line and it's too long.
1688                  *  - we used less than 80% of the width and the word we are
1689                  *    going to wrap is longer than 40% of the width, and even
1690                  *    if the word would have fit in the next line. */
1691                 if( psz_word == psz_text
1692              || ( (size_t)(psz_word - psz_text) < 80 * i_cur_width / 100
1693              && (size_t)(psz_parser - psz_word) > 40 * i_cur_width / 100 ) )
1694                 {
1695                     char c = psz_text[i_cur_width];
1696                     psz_text[i_cur_width] = '\0';
1697                     if( b_color )
1698                     {
1699                         if( !b_description || b_description_hack )
1700                             utf8_fprintf( stdout, BLUE"%s\n%s"GRAY,
1701                                           psz_text, psz_spaces );
1702                         else
1703                             utf8_fprintf( stdout, "%s\n%s",
1704                                           psz_text, psz_spaces );
1705                     }
1706                     else
1707                     {
1708                         utf8_fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
1709                     }
1710                     psz_text += i_cur_width;
1711                     psz_text[0] = c;
1712                 }
1713                 else
1714                 {
1715                     psz_word[-1] = '\0';
1716                     if( b_color )
1717                     {
1718                         if( !b_description || b_description_hack )
1719                             utf8_fprintf( stdout, BLUE"%s\n%s"GRAY,
1720                                           psz_text, psz_spaces );
1721                         else
1722                             utf8_fprintf( stdout, "%s\n%s",
1723                                           psz_text, psz_spaces );
1724                     }
1725                     else
1726                     {
1727                         utf8_fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
1728                     }
1729                     psz_text = psz_word;
1730                 }
1731             }
1732
1733             if( b_description_hack && p_item->psz_longtext )
1734             {
1735                 sprintf( psz_buffer, "%s%s", p_item->psz_longtext, psz_suf );
1736                 b_description_hack = false;
1737                 psz_spaces = psz_spaces_longtext;
1738                 utf8_fprintf( stdout, "%s", psz_spaces );
1739                 goto description;
1740             }
1741         }
1742     }
1743
1744     if( b_has_advanced ) 
1745     {
1746         if( b_color )
1747             utf8_fprintf( stdout, "\n" WHITE "%s" GRAY " %s\n", _( "Note:" ),
1748            _( "add --advanced to your command line to see advanced options."));
1749         else
1750             utf8_fprintf( stdout, "\n %s %s\n", _( "Note:" ),
1751            _( "add --advanced to your command line to see advanced options."));
1752     }
1753
1754     /* Release the module list */
1755     vlc_list_release( p_list );
1756 }
1757
1758 /*****************************************************************************
1759  * ListModules: list the available modules with their description
1760  *****************************************************************************
1761  * Print a list of all available modules (builtins and plugins) and a short
1762  * description for each one.
1763  *****************************************************************************/
1764 static void ListModules( libvlc_int_t *p_this, bool b_verbose )
1765 {
1766     vlc_list_t *p_list = NULL;
1767     module_t *p_parser = NULL;
1768     char psz_spaces[22];
1769     int i_index;
1770
1771     bool b_color = config_GetInt( p_this, "color" ) > 0;
1772
1773     memset( psz_spaces, ' ', 22 );
1774
1775 #ifdef WIN32
1776     ShowConsole( true );
1777 #endif
1778
1779     /* List all modules */
1780     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1781
1782     /* Enumerate each module */
1783     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1784     {
1785         int i;
1786
1787         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1788
1789         /* Nasty hack, but right now I'm too tired to think about a nice
1790          * solution */
1791         i = 22 - strlen( p_parser->psz_object_name ) - 1;
1792         if( i < 0 ) i = 0;
1793         psz_spaces[i] = 0;
1794
1795         if( b_color )
1796             utf8_fprintf( stdout, GREEN"  %s%s "WHITE"%s\n"GRAY,
1797                           p_parser->psz_object_name,
1798                           psz_spaces,
1799                           p_parser->psz_longname );
1800         else
1801             utf8_fprintf( stdout, "  %s%s %s\n",
1802                           p_parser->psz_object_name,
1803                           psz_spaces, p_parser->psz_longname );
1804
1805         if( b_verbose )
1806         {
1807             const char *const *pp_shortcut = p_parser->pp_shortcuts;
1808             while( *pp_shortcut )
1809             {
1810                 if( strcmp( *pp_shortcut, p_parser->psz_object_name ) )
1811                 {
1812                     if( b_color )
1813                         utf8_fprintf( stdout, CYAN"   s %s\n"GRAY,
1814                                       *pp_shortcut );
1815                     else
1816                         utf8_fprintf( stdout, "   s %s\n",
1817                                       *pp_shortcut );
1818                 }
1819                 pp_shortcut++;
1820             }
1821             if( p_parser->psz_capability )
1822             {
1823                 if( b_color )
1824                     utf8_fprintf( stdout, MAGENTA"   c %s (%d)\n"GRAY,
1825                                   p_parser->psz_capability,
1826                                   p_parser->i_score );
1827                 else
1828                     utf8_fprintf( stdout, "   c %s (%d)\n",
1829                                   p_parser->psz_capability,
1830                                   p_parser->i_score );
1831             }
1832         }
1833
1834         psz_spaces[i] = ' ';
1835     }
1836
1837     vlc_list_release( p_list );
1838
1839 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
1840     PauseConsole();
1841 #endif
1842 }
1843
1844 /*****************************************************************************
1845  * Version: print complete program version
1846  *****************************************************************************
1847  * Print complete program version and build number.
1848  *****************************************************************************/
1849 static void Version( void )
1850 {
1851 #ifdef WIN32
1852     ShowConsole( true );
1853 #endif
1854
1855     utf8_fprintf( stdout, _("VLC version %s\n"), VLC_Version() );
1856     utf8_fprintf( stdout, _("Compiled by %s@%s.%s\n"),
1857              VLC_CompileBy(), VLC_CompileHost(), VLC_CompileDomain() );
1858     utf8_fprintf( stdout, _("Compiler: %s\n"), VLC_Compiler() );
1859     if( strcmp( VLC_Changeset(), "exported" ) )
1860         utf8_fprintf( stdout, _("Based upon Git commit [%s]\n"),
1861                  VLC_Changeset() );
1862     utf8_fprintf( stdout, LICENSE_MSG );
1863
1864 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
1865     PauseConsole();
1866 #endif
1867 }
1868
1869 /*****************************************************************************
1870  * ShowConsole: On Win32, create an output console for debug messages
1871  *****************************************************************************
1872  * This function is useful only on Win32.
1873  *****************************************************************************/
1874 #ifdef WIN32 /*  */
1875 static void ShowConsole( bool b_dofile )
1876 {
1877 #   ifndef UNDER_CE
1878     FILE *f_help = NULL;
1879
1880     if( getenv( "PWD" ) && getenv( "PS1" ) ) return; /* cygwin shell */
1881
1882     AllocConsole();
1883     /* Use the ANSI code page (e.g. Windows-1252) as expected by the LibVLC
1884      * Unicode/locale subsystem. By default, we have the obsolecent OEM code
1885      * page (e.g. CP437 or CP850). */
1886     SetConsoleOutputCP (GetACP ());
1887     SetConsoleTitle ("VLC media player version "PACKAGE_VERSION);
1888
1889     freopen( "CONOUT$", "w", stderr );
1890     freopen( "CONIN$", "r", stdin );
1891
1892     if( b_dofile && (f_help = fopen( "vlc-help.txt", "wt" )) )
1893     {
1894         fclose( f_help );
1895         freopen( "vlc-help.txt", "wt", stdout );
1896         utf8_fprintf( stderr, _("\nDumped content to vlc-help.txt file.\n") );
1897     }
1898     else freopen( "CONOUT$", "w", stdout );
1899
1900 #   endif
1901 }
1902 #endif
1903
1904 /*****************************************************************************
1905  * PauseConsole: On Win32, wait for a key press before closing the console
1906  *****************************************************************************
1907  * This function is useful only on Win32.
1908  *****************************************************************************/
1909 #ifdef WIN32 /*  */
1910 static void PauseConsole( void )
1911 {
1912 #   ifndef UNDER_CE
1913
1914     if( getenv( "PWD" ) && getenv( "PS1" ) ) return; /* cygwin shell */
1915
1916     utf8_fprintf( stderr, _("\nPress the RETURN key to continue...\n") );
1917     getchar();
1918     fclose( stdout );
1919
1920 #   endif
1921 }
1922 #endif
1923
1924 /*****************************************************************************
1925  * ConsoleWidth: Return the console width in characters
1926  *****************************************************************************
1927  * We use the stty shell command to get the console width; if this fails or
1928  * if the width is less than 80, we default to 80.
1929  *****************************************************************************/
1930 static int ConsoleWidth( void )
1931 {
1932     unsigned i_width = 80;
1933
1934 #ifndef WIN32
1935     FILE *file = popen( "stty size 2>/dev/null", "r" );
1936     if (file != NULL)
1937     {
1938         if (fscanf (file, "%*u %u", &i_width) <= 0)
1939             i_width = 80;
1940         pclose( file );
1941     }
1942 #else
1943     CONSOLE_SCREEN_BUFFER_INFO buf;
1944
1945     if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &buf))
1946         i_width = buf.dwSize.X;
1947 #endif
1948
1949     return i_width;
1950 }
1951
1952 static int VerboseCallback( vlc_object_t *p_this, const char *psz_variable,
1953                      vlc_value_t old_val, vlc_value_t new_val, void *param)
1954 {
1955     libvlc_int_t *p_libvlc = (libvlc_int_t *)p_this;
1956     (void)psz_variable;
1957     (void)old_val;
1958     (void)param;
1959
1960     if( new_val.i_int >= -1 )
1961     {
1962         libvlc_priv (p_libvlc)->i_verbose = __MIN( new_val.i_int, 2 );
1963     }
1964     return VLC_SUCCESS;
1965 }
1966
1967 /*****************************************************************************
1968  * InitDeviceValues: initialize device values
1969  *****************************************************************************
1970  * This function inits the dvd, vcd and cd-audio values
1971  *****************************************************************************/
1972 static void InitDeviceValues( libvlc_int_t *p_vlc )
1973 {
1974 #ifdef HAVE_HAL
1975     LibHalContext * ctx = NULL;
1976     int i, i_devices;
1977     char **devices = NULL;
1978     char *block_dev = NULL;
1979     dbus_bool_t b_dvd;
1980
1981 #ifdef HAVE_HAL_1
1982     DBusConnection *p_connection = NULL;
1983     DBusError       error;
1984
1985     ctx = libhal_ctx_new();
1986     if( !ctx ) return;
1987     dbus_error_init( &error );
1988     p_connection = dbus_bus_get ( DBUS_BUS_SYSTEM, &error );
1989     if( dbus_error_is_set( &error ) || !p_connection )
1990     {
1991         libhal_ctx_free( ctx );
1992         dbus_error_free( &error );
1993         return;
1994     }
1995     libhal_ctx_set_dbus_connection( ctx, p_connection );
1996     if( libhal_ctx_init( ctx, &error ) )
1997 #else
1998     ctx = hal_initialize( NULL, FALSE );
1999     if( ctx )
2000 #endif
2001
2002     {
2003 #ifdef HAVE_HAL_1
2004         if( ( devices = libhal_get_all_devices( ctx, &i_devices, NULL ) ) )
2005 #else
2006         if( ( devices = hal_get_all_devices( ctx, &i_devices ) ) )
2007 #endif
2008         {
2009             for( i = 0; i < i_devices; i++ )
2010             {
2011 #ifdef HAVE_HAL_1
2012                 if( !libhal_device_property_exists( ctx, devices[i],
2013                                                 "storage.cdrom.dvd", NULL ) )
2014 #else
2015                 if( !hal_device_property_exists( ctx, devices[ i ],
2016                                                 "storage.cdrom.dvd" ) )
2017 #endif
2018                 {
2019                     continue;
2020                 }
2021 #ifdef HAVE_HAL_1
2022                 b_dvd = libhal_device_get_property_bool( ctx, devices[ i ],
2023                                                  "storage.cdrom.dvd", NULL  );
2024                 block_dev = libhal_device_get_property_string( ctx,
2025                                 devices[ i ], "block.device" , NULL );
2026 #else
2027                 b_dvd = hal_device_get_property_bool( ctx, devices[ i ],
2028                                                       "storage.cdrom.dvd" );
2029                 block_dev = hal_device_get_property_string( ctx, devices[ i ],
2030                                                             "block.device" );
2031 #endif
2032                 if( b_dvd )
2033                 {
2034                     config_PutPsz( p_vlc, "dvd", block_dev );
2035                 }
2036
2037                 config_PutPsz( p_vlc, "vcd", block_dev );
2038                 config_PutPsz( p_vlc, "cd-audio", block_dev );
2039 #ifdef HAVE_HAL_1
2040                 libhal_free_string( block_dev );
2041 #else
2042                 hal_free_string( block_dev );
2043 #endif
2044             }
2045 #ifdef HAVE_HAL_1
2046             libhal_free_string_array( devices );
2047 #else
2048             hal_free_string_array( devices );
2049 #endif
2050         }
2051
2052 #ifdef HAVE_HAL_1
2053         libhal_ctx_shutdown( ctx, NULL );
2054         dbus_connection_unref( p_connection );
2055         libhal_ctx_free( ctx );
2056 #else
2057         hal_shutdown( ctx );
2058 #endif
2059     }
2060     else
2061     {
2062         msg_Warn( p_vlc, "Unable to get HAL device properties" );
2063     }
2064 #else
2065     (void)p_vlc;
2066 #endif /* HAVE_HAL */
2067 }