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

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