git.sesse.net Git - vlc/blob - src/libvlc.c

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