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