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

   1 /*****************************************************************************
   2  * libvlc.c: main libvlc source
   3  *****************************************************************************
   4  * Copyright (C) 1998-2004 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  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Pretend we are a builtin module
  29  *****************************************************************************/
  30 #define MODULE_NAME main
  31 #define MODULE_PATH main
  32 #define __BUILTIN__
  33
  34 /*****************************************************************************
  35  * Preamble
  36  *****************************************************************************/
  37 #include <vlc/vlc.h>
  38 #include <vlc/input.h>
  39
  40 #include <errno.h>                                                 /* ENOMEM */
  41 #include <stdio.h>                                              /* sprintf() */
  42 #include <string.h>                                            /* strerror() */
  43 #include <stdlib.h>                                                /* free() */
  44
  45 #ifndef WIN32
  46 #   include <netinet/in.h>                            /* BSD: struct in_addr */
  47 #endif
  48
  49 #ifdef HAVE_UNISTD_H
  50 #   include <unistd.h>
  51 #elif defined( WIN32 ) && !defined( UNDER_CE )
  52 #   include <io.h>
  53 #endif
  54
  55 #ifdef WIN32                       /* optind, getopt(), included in unistd.h */
  56 #   include "extras/getopt.h"
  57 #endif
  58
  59 #ifdef HAVE_LOCALE_H
  60 #   include <locale.h>
  61 #endif
  62
  63 #ifdef HAVE_HAL
  64 #   include <hal/libhal.h>
  65 #endif
  66
  67 #include "vlc_cpu.h"                                        /* CPU detection */
  68 #include "os_specific.h"
  69
  70 #include "vlc_error.h"
  71
  72 #include "vlc_playlist.h"
  73 #include "vlc_interface.h"
  74
  75 #include "audio_output.h"
  76
  77 #include "vlc_video.h"
  78 #include "video_output.h"
  79
  80 #include "stream_output.h"
  81 #include "charset.h"
  82
  83 #include "libvlc.h"
  84
  85 /*****************************************************************************
  86  * The evil global variable. We handle it with care, don't worry.
  87  *****************************************************************************/
  88 static libvlc_t   libvlc;
  89 static libvlc_t * p_libvlc;
  90 static vlc_t *    p_static_vlc;
  91
  92 /*****************************************************************************
  93  * Local prototypes
  94  *****************************************************************************/
  95 static void LocaleInit( void );
  96 static void LocaleDeinit( void );
  97 static void SetLanguage   ( char const * );
  98 static int  GetFilenames  ( vlc_t *, int, char *[] );
  99 static void Help          ( vlc_t *, char const *psz_help_name );
 100 static void Usage         ( vlc_t *, char const *psz_module_name );
 101 static void ListModules   ( vlc_t * );
 102 static void Version       ( void );
 103
 104 #ifdef WIN32
 105 static void ShowConsole   ( void );
 106 static void PauseConsole  ( void );
 107 #endif
 108 static int  ConsoleWidth  ( void );
 109
 110 static int  VerboseCallback( vlc_object_t *, char const *,
 111                              vlc_value_t, vlc_value_t, void * );
 112
 113 static void InitDeviceValues( vlc_t * );
 114
 115 /*****************************************************************************
 116  * vlc_current_object: return the current object.
 117  *****************************************************************************
 118  * If i_object is non-zero, return the corresponding object. Otherwise,
 119  * return the statically allocated p_vlc object.
 120  *****************************************************************************/
 121 vlc_t * vlc_current_object( int i_object )
 122 {
 123     if( i_object )
 124     {
 125          return vlc_object_get( p_libvlc, i_object );
 126     }
 127
 128     return p_static_vlc;
 129 }
 130
 131 /*****************************************************************************
 132  * VLC_Version: return the libvlc version.
 133  *****************************************************************************
 134  * This function returns full version string (numeric version and codename).
 135  *****************************************************************************/
 136 char const * VLC_Version( void )
 137 {
 138     return VERSION_MESSAGE;
 139 }
 140
 141 /*****************************************************************************
 142  * VLC_CompileBy, VLC_CompileHost, VLC_CompileDomain,
 143  * VLC_Compiler, VLC_Changeset
 144  *****************************************************************************/
 145 #define DECLARE_VLC_VERSION( func, var )                                    \
 146 char const * VLC_##func ( void )                                            \
 147 {                                                                           \
 148     return VLC_##var ;                                                      \
 149 }
 150
 151 DECLARE_VLC_VERSION( CompileBy, COMPILE_BY );
 152 DECLARE_VLC_VERSION( CompileHost, COMPILE_HOST );
 153 DECLARE_VLC_VERSION( CompileDomain, COMPILE_DOMAIN );
 154 DECLARE_VLC_VERSION( Compiler, COMPILER );
 155
 156 extern const char psz_vlc_changeset[];
 157 char const * VLC_Changeset( void )
 158 {
 159     return psz_vlc_changeset;
 160 }
 161
 162 /*****************************************************************************
 163  * VLC_Error: strerror() equivalent
 164  *****************************************************************************
 165  * This function returns full version string (numeric version and codename).
 166  *****************************************************************************/
 167 char const * VLC_Error( int i_err )
 168 {
 169     return vlc_error( i_err );
 170 }
 171
 172 /*****************************************************************************
 173  * VLC_Create: allocate a vlc_t structure, and initialize libvlc if needed.
 174  *****************************************************************************
 175  * This function allocates a vlc_t structure and returns a negative value
 176  * in case of failure. Also, the thread system is initialized.
 177  *****************************************************************************/
 178 int VLC_Create( void )
 179 {
 180     int i_ret;
 181     vlc_t * p_vlc = NULL;
 182     vlc_value_t lockval;
 183
 184     /* &libvlc never changes, so we can safely call this multiple times. */
 185     p_libvlc = &libvlc;
 186
 187     /* vlc_threads_init *must* be the first internal call! No other call is
 188      * allowed before the thread system has been initialized. */
 189     i_ret = vlc_threads_init( p_libvlc );
 190     if( i_ret < 0 )
 191     {
 192         return i_ret;
 193     }
 194
 195     /* Now that the thread system is initialized, we don't have much, but
 196      * at least we have var_Create */
 197     var_Create( p_libvlc, "libvlc", VLC_VAR_MUTEX );
 198     var_Get( p_libvlc, "libvlc", &lockval );
 199     vlc_mutex_lock( lockval.p_address );
 200     if( !libvlc.b_ready )
 201     {
 202         char *psz_env;
 203
 204         /* Guess what CPU we have */
 205         libvlc.i_cpu = CPUCapabilities();
 206
 207         /* Find verbosity from VLC_VERBOSE environment variable */
 208         psz_env = getenv( "VLC_VERBOSE" );
 209         libvlc.i_verbose = psz_env ? atoi( psz_env ) : -1;
 210
 211 #if defined( HAVE_ISATTY ) && !defined( WIN32 )
 212         libvlc.b_color = isatty( 2 ); /* 2 is for stderr */
 213 #else
 214         libvlc.b_color = VLC_FALSE;
 215 #endif
 216
 217         /* Initialize message queue */
 218         msg_Create( p_libvlc );
 219
 220         /* Announce who we are */
 221         msg_Dbg( p_libvlc, COPYRIGHT_MESSAGE );
 222         msg_Dbg( p_libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
 223
 224         /* The module bank will be initialized later */
 225         libvlc.p_module_bank = NULL;
 226
 227         libvlc.b_ready = VLC_TRUE;
 228
 229         /* UTF-8 convertor are initialized after the locale */
 230         libvlc.from_locale = libvlc.to_locale = (vlc_iconv_t)(-1);
 231     }
 232     vlc_mutex_unlock( lockval.p_address );
 233     var_Destroy( p_libvlc, "libvlc" );
 234
 235     /* Allocate a vlc object */
 236     p_vlc = vlc_object_create( p_libvlc, VLC_OBJECT_VLC );
 237     if( p_vlc == NULL )
 238     {
 239         return VLC_EGENERIC;
 240     }
 241     p_vlc->thread_id = 0;
 242
 243     p_vlc->psz_object_name = "root";
 244
 245     /* Initialize mutexes */
 246     vlc_mutex_init( p_vlc, &p_vlc->config_lock );
 247 #ifdef SYS_DARWIN
 248     vlc_mutex_init( p_vlc, &p_vlc->quicktime_lock );
 249     vlc_thread_set_priority( p_vlc, VLC_THREAD_PRIORITY_LOW );
 250 #endif
 251
 252     /* Store our newly allocated structure in the global list */
 253     vlc_object_attach( p_vlc, p_libvlc );
 254
 255     /* Store data for the non-reentrant API */
 256     p_static_vlc = p_vlc;
 257
 258     return p_vlc->i_object_id;
 259 }
 260
 261 /*****************************************************************************
 262  * VLC_Init: initialize a vlc_t structure.
 263  *****************************************************************************
 264  * This function initializes a previously allocated vlc_t structure:
 265  *  - CPU detection
 266  *  - gettext initialization
 267  *  - message queue, module bank and playlist initialization
 268  *  - configuration and commandline parsing
 269  *****************************************************************************/
 270 int VLC_Init( int i_object, int i_argc, char *ppsz_argv[] )
 271 {
 272     char         p_capabilities[200];
 273     char *       p_tmp;
 274     char *       psz_modules;
 275     char *       psz_parser;
 276     char *       psz_control;
 277     vlc_bool_t   b_exit = VLC_FALSE;
 278     int          i_ret = VLC_EEXIT;
 279     vlc_t *      p_vlc = vlc_current_object( i_object );
 280     module_t    *p_help_module;
 281     playlist_t  *p_playlist;
 282     vlc_value_t  val;
 283 #if defined( ENABLE_NLS ) \
 284      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
 285     char *       psz_language;
 286 #endif
 287
 288     if( !p_vlc )
 289     {
 290         return VLC_ENOOBJ;
 291     }
 292
 293     /*
 294      * System specific initialization code
 295      */
 296     system_Init( p_vlc, &i_argc, ppsz_argv );
 297
 298     /* Get the executable name (similar to the basename command) */
 299     if( i_argc > 0 )
 300     {
 301         p_vlc->psz_object_name = p_tmp = ppsz_argv[ 0 ];
 302         while( *p_tmp )
 303         {
 304             if( *p_tmp == '/' ) p_vlc->psz_object_name = ++p_tmp;
 305             else ++p_tmp;
 306         }
 307     }
 308     else
 309     {
 310         p_vlc->psz_object_name = "vlc";
 311     }
 312
 313     /*
 314      * Support for gettext
 315      */
 316     SetLanguage( "" );
 317
 318     /*
 319      * Global iconv, must be done after setlocale()
 320      * so that vlc_current_charset() works.
 321      */
 322     LocaleInit();
 323
 324     /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
 325     msg_Dbg( p_vlc, "translation test: code is \"%s\"", _("C") );
 326
 327     /* Initialize the module bank and load the configuration of the
 328      * main module. We need to do this at this stage to be able to display
 329      * a short help if required by the user. (short help == main module
 330      * options) */
 331     module_InitBank( p_vlc );
 332
 333     /* Hack: insert the help module here */
 334     p_help_module = vlc_object_create( p_vlc, VLC_OBJECT_MODULE );
 335     if( p_help_module == NULL )
 336     {
 337         module_EndBank( p_vlc );
 338         if( i_object ) vlc_object_release( p_vlc );
 339         return VLC_EGENERIC;
 340     }
 341     p_help_module->psz_object_name = "help";
 342     p_help_module->psz_longname = N_("Help options");
 343     config_Duplicate( p_help_module, p_help_config );
 344     vlc_object_attach( p_help_module, libvlc.p_module_bank );
 345     /* End hack */
 346
 347     if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE ) )
 348     {
 349         vlc_object_detach( p_help_module );
 350         config_Free( p_help_module );
 351         vlc_object_destroy( p_help_module );
 352         module_EndBank( p_vlc );
 353         if( i_object ) vlc_object_release( p_vlc );
 354         return VLC_EGENERIC;
 355     }
 356
 357     /* Check for short help option */
 358     if( config_GetInt( p_vlc, "help" ) )
 359     {
 360         Help( p_vlc, "help" );
 361         b_exit = VLC_TRUE;
 362         i_ret = VLC_EEXITSUCCESS;
 363     }
 364     /* Check for version option */
 365     else if( config_GetInt( p_vlc, "version" ) )
 366     {
 367         Version();
 368         b_exit = VLC_TRUE;
 369         i_ret = VLC_EEXITSUCCESS;
 370     }
 371
 372     /* Set the config file stuff */
 373     p_vlc->psz_homedir = config_GetHomeDir();
 374     p_vlc->psz_userdir = config_GetUserDir();
 375     if( p_vlc->psz_userdir == NULL )
 376         p_vlc->psz_userdir = strdup(p_vlc->psz_homedir);
 377     p_vlc->psz_configfile = config_GetPsz( p_vlc, "config" );
 378     if( p_vlc->psz_configfile != NULL && p_vlc->psz_configfile[0] == '~'
 379          && p_vlc->psz_configfile[1] == '/' )
 380     {
 381         char *psz = malloc( strlen(p_vlc->psz_userdir)
 382                              + strlen(p_vlc->psz_configfile) );
 383         /* This is incomplete : we should also support the ~cmassiot/ syntax. */
 384         sprintf( psz, "%s/%s", p_vlc->psz_userdir,
 385                                p_vlc->psz_configfile + 2 );
 386         free( p_vlc->psz_configfile );
 387         p_vlc->psz_configfile = psz;
 388     }
 389
 390     /* Check for plugins cache options */
 391     if( config_GetInt( p_vlc, "reset-plugins-cache" ) )
 392     {
 393         libvlc.p_module_bank->b_cache_delete = VLC_TRUE;
 394     }
 395
 396     /* Hack: remove the help module here */
 397     vlc_object_detach( p_help_module );
 398     /* End hack */
 399
 400     /* Will be re-done properly later on */
 401     p_vlc->p_libvlc->i_verbose = config_GetInt( p_vlc, "verbose" );
 402
 403     /* Check for daemon mode */
 404 #ifndef WIN32
 405     if( config_GetInt( p_vlc, "daemon" ) )
 406     {
 407 #if HAVE_DAEMON
 408         if( daemon( 1, 0) != 0 )
 409         {
 410             msg_Err( p_vlc, "Unable to fork vlc to daemon mode" );
 411             b_exit = VLC_TRUE;
 412         }
 413
 414         p_vlc->p_libvlc->b_daemon = VLC_TRUE;
 415
 416 #else
 417         pid_t i_pid;
 418
 419         if( ( i_pid = fork() ) < 0 )
 420         {
 421             msg_Err( p_vlc, "Unable to fork vlc to daemon mode" );
 422             b_exit = VLC_TRUE;
 423         }
 424         else if( i_pid )
 425         {
 426             /* This is the parent, exit right now */
 427             msg_Dbg( p_vlc, "closing parent process" );
 428             b_exit = VLC_TRUE;
 429             i_ret = VLC_EEXITSUCCESS;
 430         }
 431         else
 432         {
 433             /* We are the child */
 434             msg_Dbg( p_vlc, "daemon spawned" );
 435             close( STDIN_FILENO );
 436             close( STDOUT_FILENO );
 437             close( STDERR_FILENO );
 438
 439             p_vlc->p_libvlc->b_daemon = VLC_TRUE;
 440         }
 441 #endif
 442     }
 443 #endif
 444
 445     if( b_exit )
 446     {
 447         config_Free( p_help_module );
 448         vlc_object_destroy( p_help_module );
 449         module_EndBank( p_vlc );
 450         if( i_object ) vlc_object_release( p_vlc );
 451         return i_ret;
 452     }
 453
 454     /* Check for translation config option */
 455 #if defined( ENABLE_NLS ) \
 456      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
 457
 458     /* This ain't really nice to have to reload the config here but it seems
 459      * the only way to do it. */
 460     config_LoadConfigFile( p_vlc, "main" );
 461     config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
 462
 463     /* Check if the user specified a custom language */
 464     psz_language = config_GetPsz( p_vlc, "language" );
 465     if( psz_language && *psz_language && strcmp( psz_language, "auto" ) )
 466     {
 467         vlc_bool_t b_cache_delete = libvlc.p_module_bank->b_cache_delete;
 468
 469         /* Reset the default domain */
 470         SetLanguage( psz_language );
 471         LocaleDeinit();
 472         LocaleInit();
 473
 474         /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */
 475         msg_Dbg( p_vlc, "translation test: code is \"%s\"", _("C") );
 476
 477         module_EndBank( p_vlc );
 478         module_InitBank( p_vlc );
 479         config_LoadConfigFile( p_vlc, "main" );
 480         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
 481         libvlc.p_module_bank->b_cache_delete = b_cache_delete;
 482     }
 483     if( psz_language ) free( psz_language );
 484 #endif
 485
 486     /*
 487      * Load the builtins and plugins into the module_bank.
 488      * We have to do it before config_Load*() because this also gets the
 489      * list of configuration options exported by each module and loads their
 490      * default values.
 491      */
 492     module_LoadBuiltins( p_vlc );
 493     module_LoadPlugins( p_vlc );
 494     if( p_vlc->b_die )
 495     {
 496         b_exit = VLC_TRUE;
 497     }
 498
 499     msg_Dbg( p_vlc, "module bank initialized, found %i modules",
 500                     libvlc.p_module_bank->i_children );
 501
 502     /* Hack: insert the help module here */
 503     vlc_object_attach( p_help_module, libvlc.p_module_bank );
 504     /* End hack */
 505
 506     /* Check for help on modules */
 507     if( (p_tmp = config_GetPsz( p_vlc, "module" )) )
 508     {
 509         Help( p_vlc, p_tmp );
 510         free( p_tmp );
 511         b_exit = VLC_TRUE;
 512         i_ret = VLC_EEXITSUCCESS;
 513     }
 514     /* Check for long help option */
 515     else if( config_GetInt( p_vlc, "longhelp" ) )
 516     {
 517         Help( p_vlc, "longhelp" );
 518         b_exit = VLC_TRUE;
 519         i_ret = VLC_EEXITSUCCESS;
 520     }
 521     /* Check for module list option */
 522     else if( config_GetInt( p_vlc, "list" ) )
 523     {
 524         ListModules( p_vlc );
 525         b_exit = VLC_TRUE;
 526         i_ret = VLC_EEXITSUCCESS;
 527     }
 528
 529     /* Check for config file options */
 530     if( config_GetInt( p_vlc, "reset-config" ) )
 531     {
 532         vlc_object_detach( p_help_module );
 533         config_ResetAll( p_vlc );
 534         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
 535         config_SaveConfigFile( p_vlc, NULL );
 536         vlc_object_attach( p_help_module, libvlc.p_module_bank );
 537     }
 538     if( config_GetInt( p_vlc, "save-config" ) )
 539     {
 540         vlc_object_detach( p_help_module );
 541         config_LoadConfigFile( p_vlc, NULL );
 542         config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE );
 543         config_SaveConfigFile( p_vlc, NULL );
 544         vlc_object_attach( p_help_module, libvlc.p_module_bank );
 545     }
 546
 547     /* Hack: remove the help module here */
 548     vlc_object_detach( p_help_module );
 549     /* End hack */
 550
 551     if( b_exit )
 552     {
 553         config_Free( p_help_module );
 554         vlc_object_destroy( p_help_module );
 555         module_EndBank( p_vlc );
 556         if( i_object ) vlc_object_release( p_vlc );
 557         return i_ret;
 558     }
 559
 560     /*
 561      * Init device values
 562      */
 563     InitDeviceValues( p_vlc );
 564
 565     /*
 566      * Override default configuration with config file settings
 567      */
 568     config_LoadConfigFile( p_vlc, NULL );
 569
 570     /* Hack: insert the help module here */
 571     vlc_object_attach( p_help_module, libvlc.p_module_bank );
 572     /* End hack */
 573
 574     /*
 575      * Override configuration with command line settings
 576      */
 577     if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_FALSE ) )
 578     {
 579 #ifdef WIN32
 580         ShowConsole();
 581         /* Pause the console because it's destroyed when we exit */
 582         fprintf( stderr, "The command line options couldn't be loaded, check "
 583                  "that they are valid.\n" );
 584         PauseConsole();
 585 #endif
 586         vlc_object_detach( p_help_module );
 587         config_Free( p_help_module );
 588         vlc_object_destroy( p_help_module );
 589         module_EndBank( p_vlc );
 590         if( i_object ) vlc_object_release( p_vlc );
 591         return VLC_EGENERIC;
 592     }
 593
 594     /* Hack: remove the help module here */
 595     vlc_object_detach( p_help_module );
 596     config_Free( p_help_module );
 597     vlc_object_destroy( p_help_module );
 598     /* End hack */
 599
 600     /*
 601      * System specific configuration
 602      */
 603     system_Configure( p_vlc, &i_argc, ppsz_argv );
 604
 605     /*
 606      * Message queue options
 607      */
 608
 609     var_Create( p_vlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 610     if( config_GetInt( p_vlc, "quiet" ) )
 611     {
 612         val.i_int = -1;
 613         var_Set( p_vlc, "verbose", val );
 614     }
 615     var_AddCallback( p_vlc, "verbose", VerboseCallback, NULL );
 616     var_Change( p_vlc, "verbose", VLC_VAR_TRIGGER_CALLBACKS, NULL, NULL );
 617
 618     libvlc.b_color = libvlc.b_color && config_GetInt( p_vlc, "color" );
 619
 620     /*
 621      * Output messages that may still be in the queue
 622      */
 623     msg_Flush( p_vlc );
 624
 625     /* p_vlc initialization. FIXME ? */
 626
 627     if( !config_GetInt( p_vlc, "fpu" ) )
 628         libvlc.i_cpu &= ~CPU_CAPABILITY_FPU;
 629
 630 #if defined( __i386__ ) || defined( __x86_64__ )
 631     if( !config_GetInt( p_vlc, "mmx" ) )
 632         libvlc.i_cpu &= ~CPU_CAPABILITY_MMX;
 633     if( !config_GetInt( p_vlc, "3dn" ) )
 634         libvlc.i_cpu &= ~CPU_CAPABILITY_3DNOW;
 635     if( !config_GetInt( p_vlc, "mmxext" ) )
 636         libvlc.i_cpu &= ~CPU_CAPABILITY_MMXEXT;
 637     if( !config_GetInt( p_vlc, "sse" ) )
 638         libvlc.i_cpu &= ~CPU_CAPABILITY_SSE;
 639     if( !config_GetInt( p_vlc, "sse2" ) )
 640         libvlc.i_cpu &= ~CPU_CAPABILITY_SSE2;
 641 #endif
 642 #if defined( __powerpc__ ) || defined( SYS_DARWIN )
 643     if( !config_GetInt( p_vlc, "altivec" ) )
 644         libvlc.i_cpu &= ~CPU_CAPABILITY_ALTIVEC;
 645 #endif
 646
 647 #define PRINT_CAPABILITY( capability, string )                              \
 648     if( libvlc.i_cpu & capability )                                         \
 649     {                                                                       \
 650         strncat( p_capabilities, string " ",                                \
 651                  sizeof(p_capabilities) - strlen(p_capabilities) );         \
 652         p_capabilities[sizeof(p_capabilities) - 1] = '\0';                  \
 653     }
 654
 655     p_capabilities[0] = '\0';
 656     PRINT_CAPABILITY( CPU_CAPABILITY_486, "486" );
 657     PRINT_CAPABILITY( CPU_CAPABILITY_586, "586" );
 658     PRINT_CAPABILITY( CPU_CAPABILITY_PPRO, "Pentium Pro" );
 659     PRINT_CAPABILITY( CPU_CAPABILITY_MMX, "MMX" );
 660     PRINT_CAPABILITY( CPU_CAPABILITY_3DNOW, "3DNow!" );
 661     PRINT_CAPABILITY( CPU_CAPABILITY_MMXEXT, "MMXEXT" );
 662     PRINT_CAPABILITY( CPU_CAPABILITY_SSE, "SSE" );
 663     PRINT_CAPABILITY( CPU_CAPABILITY_SSE2, "SSE2" );
 664     PRINT_CAPABILITY( CPU_CAPABILITY_ALTIVEC, "AltiVec" );
 665     PRINT_CAPABILITY( CPU_CAPABILITY_FPU, "FPU" );
 666     msg_Dbg( p_vlc, "CPU has capabilities %s", p_capabilities );
 667
 668     /*
 669      * Choose the best memcpy module
 670      */
 671     p_vlc->p_memcpy_module = module_Need( p_vlc, "memcpy", "$memcpy", 0 );
 672
 673     if( p_vlc->pf_memcpy == NULL )
 674     {
 675         p_vlc->pf_memcpy = memcpy;
 676     }
 677
 678     if( p_vlc->pf_memset == NULL )
 679     {
 680         p_vlc->pf_memset = memset;
 681     }
 682
 683     libvlc.b_stats = config_GetInt( p_vlc, "stats" );
 684
 685     /*
 686      * Initialize hotkey handling
 687      */
 688     var_Create( p_vlc, "key-pressed", VLC_VAR_INTEGER );
 689     p_vlc->p_hotkeys = malloc( sizeof(p_hotkeys) );
 690     /* Do a copy (we don't need to modify the strings) */
 691     memcpy( p_vlc->p_hotkeys, p_hotkeys, sizeof(p_hotkeys) );
 692
 693     /*
 694      * Initialize playlist and get commandline files
 695      */
 696     p_playlist = playlist_Create( p_vlc );
 697     if( !p_playlist )
 698     {
 699         msg_Err( p_vlc, "playlist initialization failed" );
 700         if( p_vlc->p_memcpy_module != NULL )
 701         {
 702             module_Unneed( p_vlc, p_vlc->p_memcpy_module );
 703         }
 704         module_EndBank( p_vlc );
 705         if( i_object ) vlc_object_release( p_vlc );
 706         return VLC_EGENERIC;
 707     }
 708
 709     psz_modules = config_GetPsz( p_playlist, "services-discovery" );
 710     if( psz_modules && *psz_modules )
 711     {
 712         /* Add service discovery modules */
 713         playlist_AddSDModules( p_playlist, psz_modules );
 714     }
 715     if( psz_modules ) free( psz_modules );
 716
 717     /*
 718      * Load background interfaces
 719      */
 720     psz_modules = config_GetPsz( p_vlc, "extraintf" );
 721     psz_control = config_GetPsz( p_vlc, "control" );
 722
 723     if( psz_modules && *psz_modules && psz_control && *psz_control )
 724     {
 725         psz_modules = (char *)realloc( psz_modules, strlen( psz_modules ) +
 726                                                     strlen( psz_control ) + 1 );
 727         sprintf( psz_modules, "%s:%s", psz_modules, psz_control );
 728     }
 729     else if( psz_control && *psz_control )
 730     {
 731         if( psz_modules ) free( psz_modules );
 732         psz_modules = strdup( psz_control );
 733     }
 734
 735     psz_parser = psz_modules;
 736     while ( psz_parser && *psz_parser )
 737     {
 738         char *psz_module, *psz_temp;
 739         psz_module = psz_parser;
 740         psz_parser = strchr( psz_module, ':' );
 741         if ( psz_parser )
 742         {
 743             *psz_parser = '\0';
 744             psz_parser++;
 745         }
 746         psz_temp = (char *)malloc( strlen(psz_module) + sizeof(",none") );
 747         if( psz_temp )
 748         {
 749             sprintf( psz_temp, "%s,none", psz_module );
 750             VLC_AddIntf( 0, psz_temp, VLC_FALSE, VLC_FALSE );
 751             free( psz_temp );
 752         }
 753     }
 754     if ( psz_modules )
 755     {
 756         free( psz_modules );
 757     }
 758
 759     /*
 760      * Always load the hotkeys interface if it exists
 761      */
 762     VLC_AddIntf( 0, "hotkeys,none", VLC_FALSE, VLC_FALSE );
 763
 764     /*
 765      * If needed, load the Xscreensaver interface
 766      * Currently, only for X
 767      */
 768 #ifdef HAVE_X11_XLIB_H
 769     if( config_GetInt( p_vlc, "disable-screensaver" ) == 1 )
 770     {
 771         VLC_AddIntf( 0, "screensaver", VLC_FALSE, VLC_FALSE );
 772     }
 773 #endif
 774
 775     /*
 776      * FIXME: kludge to use a p_vlc-local variable for the Mozilla plugin
 777      */
 778     var_Create( p_vlc, "drawable", VLC_VAR_INTEGER );
 779     var_Create( p_vlc, "drawableredraw", VLC_VAR_INTEGER );
 780     var_Create( p_vlc, "drawablet", VLC_VAR_INTEGER );
 781     var_Create( p_vlc, "drawablel", VLC_VAR_INTEGER );
 782     var_Create( p_vlc, "drawableb", VLC_VAR_INTEGER );
 783     var_Create( p_vlc, "drawabler", VLC_VAR_INTEGER );
 784     var_Create( p_vlc, "drawablex", VLC_VAR_INTEGER );
 785     var_Create( p_vlc, "drawabley", VLC_VAR_INTEGER );
 786     var_Create( p_vlc, "drawablew", VLC_VAR_INTEGER );
 787     var_Create( p_vlc, "drawableh", VLC_VAR_INTEGER );
 788     var_Create( p_vlc, "drawableportx", VLC_VAR_INTEGER );
 789     var_Create( p_vlc, "drawableporty", VLC_VAR_INTEGER );
 790
 791     /* Create volume callback system. */
 792     var_Create( p_vlc, "volume-change", VLC_VAR_BOOL );
 793
 794     /*
 795      * Get input filenames given as commandline arguments
 796      */
 797     GetFilenames( p_vlc, i_argc, ppsz_argv );
 798
 799     /*
 800      * Get --open argument
 801      */
 802     var_Create( p_vlc, "open", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 803     var_Get( p_vlc, "open", &val );
 804     if ( val.psz_string != NULL && *val.psz_string )
 805     {
 806         VLC_AddTarget( p_vlc->i_object_id, val.psz_string, NULL, 0,
 807                        PLAYLIST_INSERT, 0 );
 808     }
 809     if ( val.psz_string != NULL ) free( val.psz_string );
 810
 811     if( i_object ) vlc_object_release( p_vlc );
 812     return VLC_SUCCESS;
 813 }
 814
 815 /*****************************************************************************
 816  * VLC_AddIntf: add an interface
 817  *****************************************************************************
 818  * This function opens an interface plugin and runs it. If b_block is set
 819  * to 0, VLC_AddIntf will return immediately and let the interface run in a
 820  * separate thread. If b_block is set to 1, VLC_AddIntf will continue until
 821  * user requests to quit. If b_play is set to 1, VLC_AddIntf will start playing
 822  * the playlist when it is completely initialised.
 823  *****************************************************************************/
 824 int VLC_AddIntf( int i_object, char const *psz_module,
 825                  vlc_bool_t b_block, vlc_bool_t b_play )
 826 {
 827     int i_err;
 828     intf_thread_t *p_intf;
 829     vlc_t *p_vlc = vlc_current_object( i_object );
 830
 831     if( !p_vlc )
 832     {
 833         return VLC_ENOOBJ;
 834     }
 835
 836 #ifndef WIN32
 837     if( p_vlc->p_libvlc->b_daemon && b_block && !psz_module )
 838     {
 839         /* Daemon mode hack.
 840          * We prefer the dummy interface if none is specified. */
 841         char *psz_interface = config_GetPsz( p_vlc, "intf" );
 842         if( !psz_interface || !*psz_interface ) psz_module = "dummy";
 843         if( psz_interface ) free( psz_interface );
 844     }
 845 #endif
 846
 847     /* Try to create the interface */
 848     p_intf = intf_Create( p_vlc, psz_module ? psz_module : "$intf" );
 849
 850     if( p_intf == NULL )
 851     {
 852         msg_Err( p_vlc, "interface \"%s\" initialization failed", psz_module );
 853         if( i_object ) vlc_object_release( p_vlc );
 854         return VLC_EGENERIC;
 855     }
 856
 857     /* Interface doesn't handle play on start so do it ourselves */
 858     if( !p_intf->b_play && b_play ) VLC_Play( i_object );
 859
 860     /* Try to run the interface */
 861     p_intf->b_play = b_play;
 862     p_intf->b_block = b_block;
 863     i_err = intf_RunThread( p_intf );
 864     if( i_err )
 865     {
 866         vlc_object_detach( p_intf );
 867         intf_Destroy( p_intf );
 868         if( i_object ) vlc_object_release( p_vlc );
 869         return i_err;
 870     }
 871
 872     if( i_object ) vlc_object_release( p_vlc );
 873     return VLC_SUCCESS;
 874 }
 875
 876 /*****************************************************************************
 877  * VLC_Die: ask vlc to die.
 878  *****************************************************************************
 879  * This function sets p_vlc->b_die to VLC_TRUE, but does not do any other
 880  * task. It is your duty to call VLC_CleanUp and VLC_Destroy afterwards.
 881  *****************************************************************************/
 882 int VLC_Die( int i_object )
 883 {
 884     vlc_t *p_vlc = vlc_current_object( i_object );
 885
 886     if( !p_vlc )
 887     {
 888         return VLC_ENOOBJ;
 889     }
 890
 891     p_vlc->b_die = VLC_TRUE;
 892
 893     if( i_object ) vlc_object_release( p_vlc );
 894     return VLC_SUCCESS;
 895 }
 896
 897 /*****************************************************************************
 898  * VLC_CleanUp: CleanUp all the intf, playlist, vout, aout
 899  *****************************************************************************/
 900 int VLC_CleanUp( int i_object )
 901 {
 902     intf_thread_t      * p_intf;
 903     playlist_t         * p_playlist;
 904     vout_thread_t      * p_vout;
 905     aout_instance_t    * p_aout;
 906     announce_handler_t * p_announce;
 907     stats_handler_t    * p_stats;
 908     vlc_t *p_vlc = vlc_current_object( i_object );
 909
 910     /* Check that the handle is valid */
 911     if( !p_vlc )
 912     {
 913         return VLC_ENOOBJ;
 914     }
 915
 916     /*
 917      * Ask the interfaces to stop and destroy them
 918      */
 919     msg_Dbg( p_vlc, "removing all interfaces" );
 920     while( (p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_CHILD )) )
 921     {
 922         intf_StopThread( p_intf );
 923         vlc_object_detach( p_intf );
 924         vlc_object_release( p_intf );
 925         intf_Destroy( p_intf );
 926     }
 927
 928     /*
 929      * Free playlist
 930      */
 931     msg_Dbg( p_vlc, "removing playlist handler" );
 932     while( (p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST,
 933                                           FIND_CHILD )) )
 934     {
 935         vlc_object_detach( p_playlist );
 936         vlc_object_release( p_playlist );
 937         playlist_Destroy( p_playlist );
 938     }
 939
 940     /*
 941      * Free video outputs
 942      */
 943     msg_Dbg( p_vlc, "removing all video outputs" );
 944     while( (p_vout = vlc_object_find( p_vlc, VLC_OBJECT_VOUT, FIND_CHILD )) )
 945     {
 946         vlc_object_detach( p_vout );
 947         vlc_object_release( p_vout );
 948         vout_Destroy( p_vout );
 949     }
 950
 951     /*
 952      * Free audio outputs
 953      */
 954     msg_Dbg( p_vlc, "removing all audio outputs" );
 955     while( (p_aout = vlc_object_find( p_vlc, VLC_OBJECT_AOUT, FIND_CHILD )) )
 956     {
 957         vlc_object_detach( (vlc_object_t *)p_aout );
 958         vlc_object_release( (vlc_object_t *)p_aout );
 959         aout_Delete( p_aout );
 960     }
 961
 962     while( ( p_stats = vlc_object_find( p_vlc, VLC_OBJECT_STATS, FIND_CHILD) ))
 963     {
 964         vlc_object_detach( (vlc_object_t*) p_stats );
 965         vlc_object_release( (vlc_object_t *)p_stats );
 966         // TODO: Delete it
 967     }
 968
 969     /*
 970      * Free announce handler(s?)
 971      */
 972     while( (p_announce = vlc_object_find( p_vlc, VLC_OBJECT_ANNOUNCE,
 973                                                  FIND_CHILD ) ) )
 974     {
 975         msg_Dbg( p_vlc, "removing announce handler" );
 976         vlc_object_detach( p_announce );
 977         vlc_object_release( p_announce );
 978         announce_HandlerDestroy( p_announce );
 979     }
 980
 981     if( i_object ) vlc_object_release( p_vlc );
 982     return VLC_SUCCESS;
 983 }
 984
 985 /*****************************************************************************
 986  * VLC_Destroy: Destroy everything.
 987  *****************************************************************************
 988  * This function requests the running threads to finish, waits for their
 989  * termination, and destroys their structure.
 990  *****************************************************************************/
 991 int VLC_Destroy( int i_object )
 992 {
 993     vlc_t *p_vlc = vlc_current_object( i_object );
 994
 995     if( !p_vlc )
 996     {
 997         return VLC_ENOOBJ;
 998     }
 999
1000     /*
1001      * Free allocated memory
1002      */
1003     if( p_vlc->p_memcpy_module )
1004     {
1005         module_Unneed( p_vlc, p_vlc->p_memcpy_module );
1006         p_vlc->p_memcpy_module = NULL;
1007     }
1008
1009     /*
1010      * Free module bank !
1011      */
1012     module_EndBank( p_vlc );
1013
1014     if( p_vlc->psz_homedir )
1015     {
1016         free( p_vlc->psz_homedir );
1017         p_vlc->psz_homedir = NULL;
1018     }
1019
1020     if( p_vlc->psz_userdir )
1021     {
1022         free( p_vlc->psz_userdir );
1023         p_vlc->psz_userdir = NULL;
1024     }
1025
1026     if( p_vlc->psz_configfile )
1027     {
1028         free( p_vlc->psz_configfile );
1029         p_vlc->psz_configfile = NULL;
1030     }
1031
1032     if( p_vlc->p_hotkeys )
1033     {
1034         free( p_vlc->p_hotkeys );
1035         p_vlc->p_hotkeys = NULL;
1036     }
1037
1038     /*
1039      * System specific cleaning code
1040      */
1041     system_End( p_vlc );
1042
1043     /*
1044      * Free message queue.
1045      * Nobody shall use msg_* afterward.
1046      */
1047     msg_Flush( p_vlc );
1048     msg_Destroy( p_libvlc );
1049
1050     /* Destroy global iconv */
1051     LocaleDeinit();
1052
1053     /* Destroy mutexes */
1054     vlc_mutex_destroy( &p_vlc->config_lock );
1055
1056     vlc_object_detach( p_vlc );
1057
1058     /* Release object before destroying it */
1059     if( i_object ) vlc_object_release( p_vlc );
1060
1061     vlc_object_destroy( p_vlc );
1062
1063     /* Stop thread system: last one out please shut the door! */
1064     vlc_threads_end( p_libvlc );
1065
1066     return VLC_SUCCESS;
1067 }
1068
1069 /*****************************************************************************
1070  * VLC_VariableSet: set a vlc variable
1071  *****************************************************************************/
1072 int VLC_VariableSet( int i_object, char const *psz_var, vlc_value_t value )
1073 {
1074     vlc_t *p_vlc = vlc_current_object( i_object );
1075     int i_ret;
1076
1077     if( !p_vlc )
1078     {
1079         return VLC_ENOOBJ;
1080     }
1081
1082     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
1083      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
1084     if( !strncmp( psz_var, "conf::", 6 ) )
1085     {
1086         module_config_t *p_item;
1087         char const *psz_newvar = psz_var + 6;
1088
1089         p_item = config_FindConfig( VLC_OBJECT(p_vlc), psz_newvar );
1090
1091         if( p_item )
1092         {
1093             switch( p_item->i_type )
1094             {
1095                 case CONFIG_ITEM_BOOL:
1096                     config_PutInt( p_vlc, psz_newvar, value.b_bool );
1097                     break;
1098                 case CONFIG_ITEM_INTEGER:
1099                     config_PutInt( p_vlc, psz_newvar, value.i_int );
1100                     break;
1101                 case CONFIG_ITEM_FLOAT:
1102                     config_PutFloat( p_vlc, psz_newvar, value.f_float );
1103                     break;
1104                 default:
1105                     config_PutPsz( p_vlc, psz_newvar, value.psz_string );
1106                     break;
1107             }
1108             if( i_object ) vlc_object_release( p_vlc );
1109             return VLC_SUCCESS;
1110         }
1111     }
1112
1113     i_ret = var_Set( p_vlc, psz_var, value );
1114
1115     if( i_object ) vlc_object_release( p_vlc );
1116     return i_ret;
1117 }
1118
1119 /*****************************************************************************
1120  * VLC_VariableGet: get a vlc variable
1121  *****************************************************************************/
1122 int VLC_VariableGet( int i_object, char const *psz_var, vlc_value_t *p_value )
1123 {
1124     vlc_t *p_vlc = vlc_current_object( i_object );
1125     int i_ret;
1126
1127     if( !p_vlc )
1128     {
1129         return VLC_ENOOBJ;
1130     }
1131
1132     i_ret = var_Get( p_vlc , psz_var, p_value );
1133
1134     if( i_object ) vlc_object_release( p_vlc );
1135     return i_ret;
1136 }
1137
1138 /*****************************************************************************
1139  * VLC_VariableType: get a vlc variable type
1140  *****************************************************************************/
1141 int VLC_VariableType( int i_object, char const *psz_var, int *pi_type )
1142 {
1143     int i_type;
1144     vlc_t *p_vlc = vlc_current_object( i_object );
1145
1146     if( !p_vlc )
1147     {
1148         return VLC_ENOOBJ;
1149     }
1150
1151     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then
1152      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */
1153     if( !strncmp( psz_var, "conf::", 6 ) )
1154     {
1155         module_config_t *p_item;
1156         char const *psz_newvar = psz_var + 6;
1157
1158         p_item = config_FindConfig( VLC_OBJECT(p_vlc), psz_newvar );
1159
1160         if( p_item )
1161         {
1162             switch( p_item->i_type )
1163             {
1164                 case CONFIG_ITEM_BOOL:
1165                     i_type = VLC_VAR_BOOL;
1166                     break;
1167                 case CONFIG_ITEM_INTEGER:
1168                     i_type = VLC_VAR_INTEGER;
1169                     break;
1170                 case CONFIG_ITEM_FLOAT:
1171                     i_type = VLC_VAR_FLOAT;
1172                     break;
1173                 default:
1174                     i_type = VLC_VAR_STRING;
1175                     break;
1176             }
1177         }
1178         else
1179             i_type = 0;
1180     }
1181     else
1182         i_type = VLC_VAR_TYPE & var_Type( p_vlc , psz_var );
1183
1184     if( i_object ) vlc_object_release( p_vlc );
1185
1186     if( i_type > 0 )
1187     {
1188         *pi_type = i_type;
1189         return VLC_SUCCESS;
1190     }
1191     return VLC_ENOVAR;
1192 }
1193
1194 /*****************************************************************************
1195  * VLC_AddTarget: adds a target for playing.
1196  *****************************************************************************
1197  * This function adds psz_target to the current playlist. If a playlist does
1198  * not exist, it will create one.
1199  *****************************************************************************/
1200 int VLC_AddTarget( int i_object, char const *psz_target,
1201                    char const **ppsz_options, int i_options,
1202                    int i_mode, int i_pos )
1203 {
1204     int i_err;
1205     playlist_t *p_playlist;
1206     vlc_t *p_vlc = vlc_current_object( i_object );
1207
1208     if( !p_vlc )
1209     {
1210         return VLC_ENOOBJ;
1211     }
1212
1213     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1214
1215     if( p_playlist == NULL )
1216     {
1217         msg_Dbg( p_vlc, "no playlist present, creating one" );
1218         p_playlist = playlist_Create( p_vlc );
1219
1220         if( p_playlist == NULL )
1221         {
1222             if( i_object ) vlc_object_release( p_vlc );
1223             return VLC_EGENERIC;
1224         }
1225
1226         vlc_object_yield( p_playlist );
1227     }
1228
1229     i_err = playlist_AddExt( p_playlist, psz_target, psz_target,
1230                              i_mode, i_pos, -1, ppsz_options, i_options);
1231
1232     vlc_object_release( p_playlist );
1233
1234     if( i_object ) vlc_object_release( p_vlc );
1235     return i_err;
1236 }
1237
1238 /*****************************************************************************
1239  * VLC_Play: play the playlist
1240  *****************************************************************************/
1241 int VLC_Play( int i_object )
1242 {
1243     playlist_t * p_playlist;
1244     vlc_t *p_vlc = vlc_current_object( i_object );
1245
1246     /* Check that the handle is valid */
1247     if( !p_vlc )
1248     {
1249         return VLC_ENOOBJ;
1250     }
1251
1252     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1253
1254     if( !p_playlist )
1255     {
1256         if( i_object ) vlc_object_release( p_vlc );
1257         return VLC_ENOOBJ;
1258     }
1259
1260     playlist_Play( p_playlist );
1261     vlc_object_release( p_playlist );
1262
1263     if( i_object ) vlc_object_release( p_vlc );
1264     return VLC_SUCCESS;
1265 }
1266
1267 /*****************************************************************************
1268  * VLC_Pause: toggle pause
1269  *****************************************************************************/
1270 int VLC_Pause( int i_object )
1271 {
1272     playlist_t * p_playlist;
1273     vlc_t *p_vlc = vlc_current_object( i_object );
1274
1275     /* Check that the handle is valid */
1276     if( !p_vlc )
1277     {
1278         return VLC_ENOOBJ;
1279     }
1280
1281     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1282
1283     if( !p_playlist )
1284     {
1285         if( i_object ) vlc_object_release( p_vlc );
1286         return VLC_ENOOBJ;
1287     }
1288
1289     playlist_Pause( p_playlist );
1290     vlc_object_release( p_playlist );
1291
1292     if( i_object ) vlc_object_release( p_vlc );
1293     return VLC_SUCCESS;
1294 }
1295
1296 /*****************************************************************************
1297  * VLC_Pause: toggle pause
1298  *****************************************************************************/
1299 int VLC_Stop( int i_object )
1300 {
1301     playlist_t * p_playlist;
1302     vlc_t *p_vlc = vlc_current_object( i_object );
1303
1304     /* Check that the handle is valid */
1305     if( !p_vlc )
1306     {
1307         return VLC_ENOOBJ;
1308     }
1309
1310     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1311
1312     if( !p_playlist )
1313     {
1314         if( i_object ) vlc_object_release( p_vlc );
1315         return VLC_ENOOBJ;
1316     }
1317
1318     playlist_Stop( p_playlist );
1319     vlc_object_release( p_playlist );
1320
1321     if( i_object ) vlc_object_release( p_vlc );
1322     return VLC_SUCCESS;
1323 }
1324
1325 /*****************************************************************************
1326  * VLC_IsPlaying: Query for Playlist Status
1327  *****************************************************************************/
1328 vlc_bool_t VLC_IsPlaying( int i_object )
1329 {
1330     playlist_t * p_playlist;
1331     vlc_bool_t   b_playing;
1332
1333     vlc_t *p_vlc = vlc_current_object( i_object );
1334
1335     /* Check that the handle is valid */
1336     if( !p_vlc )
1337     {
1338         return VLC_ENOOBJ;
1339     }
1340
1341     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1342
1343     if( !p_playlist )
1344     {
1345         if( i_object ) vlc_object_release( p_vlc );
1346         return VLC_ENOOBJ;
1347     }
1348
1349     if( p_playlist->p_input )
1350     {
1351         vlc_value_t  val;
1352         var_Get( p_playlist->p_input, "state", &val );
1353         b_playing = ( val.i_int == PLAYING_S );
1354     }
1355     else
1356     {
1357         msg_Dbg(p_vlc, "polling playlist_IsPlaying");
1358         b_playing = playlist_IsPlaying( p_playlist );
1359     }
1360     vlc_object_release( p_playlist );
1361
1362     if( i_object ) vlc_object_release( p_vlc );
1363     return b_playing;
1364 }
1365
1366 /**
1367  * Get the current position in a input
1368  *
1369  * Return the current position as a float
1370  * \note For some inputs, this will be unknown.
1371  *
1372  * \param i_object a vlc object id
1373  * \return a float in the range of 0.0 - 1.0
1374  */
1375 float VLC_PositionGet( int i_object )
1376 {
1377     input_thread_t *p_input;
1378     vlc_value_t val;
1379     vlc_t *p_vlc = vlc_current_object( i_object );
1380
1381     /* Check that the handle is valid */
1382     if( !p_vlc )
1383     {
1384         return VLC_ENOOBJ;
1385     }
1386
1387     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1388
1389     if( !p_input )
1390     {
1391         if( i_object ) vlc_object_release( p_vlc );
1392         return VLC_ENOOBJ;
1393     }
1394
1395     var_Get( p_input, "position", &val );
1396     vlc_object_release( p_input );
1397
1398     if( i_object ) vlc_object_release( p_vlc );
1399     return val.f_float;
1400 }
1401
1402 /**
1403  * Set the current position in a input
1404  *
1405  * Set the current position in a input and then return
1406  * the current position as a float.
1407  * \note For some inputs, this will be unknown.
1408  *
1409  * \param i_object a vlc object id
1410  * \param i_position a float in the range of 0.0 - 1.0
1411  * \return a float in the range of 0.0 - 1.0
1412  */
1413 float VLC_PositionSet( int i_object, float i_position )
1414 {
1415     input_thread_t *p_input;
1416     vlc_value_t val;
1417     vlc_t *p_vlc = vlc_current_object( i_object );
1418
1419     /* Check that the handle is valid */
1420     if( !p_vlc )
1421     {
1422         return VLC_ENOOBJ;
1423     }
1424
1425     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1426
1427     if( !p_input )
1428     {
1429         if( i_object ) vlc_object_release( p_vlc );
1430         return VLC_ENOOBJ;
1431     }
1432
1433     val.f_float = i_position;
1434     var_Set( p_input, "position", val );
1435     var_Get( p_input, "position", &val );
1436     vlc_object_release( p_input );
1437
1438     if( i_object ) vlc_object_release( p_vlc );
1439     return val.f_float;
1440 }
1441
1442 /**
1443  * Get the current position in a input
1444  *
1445  * Return the current position in seconds from the start.
1446  * \note For some inputs, this will be unknown.
1447  *
1448  * \param i_object a vlc object id
1449  * \return the offset from 0:00 in seconds
1450  */
1451 int VLC_TimeGet( int i_object )
1452 {
1453     input_thread_t *p_input;
1454     vlc_value_t val;
1455     vlc_t *p_vlc = vlc_current_object( i_object );
1456
1457     /* Check that the handle is valid */
1458     if( !p_vlc )
1459     {
1460         return VLC_ENOOBJ;
1461     }
1462
1463     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1464
1465     if( !p_input )
1466     {
1467         if( i_object ) vlc_object_release( p_vlc );
1468         return VLC_ENOOBJ;
1469     }
1470
1471     var_Get( p_input, "time", &val );
1472     vlc_object_release( p_input );
1473
1474     if( i_object ) vlc_object_release( p_vlc );
1475     return val.i_time  / 1000000;
1476 }
1477
1478 /**
1479  * Seek to a position in the current input
1480  *
1481  * Seek i_seconds in the current input. If b_relative is set,
1482  * then the seek will be relative to the current position, otherwise
1483  * it will seek to i_seconds from the beginning of the input.
1484  * \note For some inputs, this will be unknown.
1485  *
1486  * \param i_object a vlc object id
1487  * \param i_seconds seconds from current position or from beginning of input
1488  * \param b_relative seek relative from current position
1489  * \return VLC_SUCCESS on success
1490  */
1491 int VLC_TimeSet( int i_object, int i_seconds, vlc_bool_t b_relative )
1492 {
1493     input_thread_t *p_input;
1494     vlc_value_t val;
1495     vlc_t *p_vlc = vlc_current_object( i_object );
1496
1497     /* Check that the handle is valid */
1498     if( !p_vlc )
1499     {
1500         return VLC_ENOOBJ;
1501     }
1502
1503     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1504
1505     if( !p_input )
1506     {
1507         if( i_object ) vlc_object_release( p_vlc );
1508         return VLC_ENOOBJ;
1509     }
1510
1511     if( b_relative )
1512     {
1513         val.i_time = i_seconds;
1514         val.i_time = val.i_time * 1000000L;
1515         var_Set( p_input, "time-offset", val );
1516     }
1517     else
1518     {
1519         val.i_time = i_seconds;
1520         val.i_time = val.i_time * 1000000L;
1521         var_Set( p_input, "time", val );
1522     }
1523     vlc_object_release( p_input );
1524
1525     if( i_object ) vlc_object_release( p_vlc );
1526     return VLC_SUCCESS;
1527 }
1528
1529 /**
1530  * Get the total length of a input
1531  *
1532  * Return the total length in seconds from the current input.
1533  * \note For some inputs, this will be unknown.
1534  *
1535  * \param i_object a vlc object id
1536  * \return the length in seconds
1537  */
1538 int VLC_LengthGet( int i_object )
1539 {
1540     input_thread_t *p_input;
1541     vlc_value_t val;
1542     vlc_t *p_vlc = vlc_current_object( i_object );
1543
1544     /* Check that the handle is valid */
1545     if( !p_vlc )
1546     {
1547         return VLC_ENOOBJ;
1548     }
1549
1550     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1551
1552     if( !p_input )
1553     {
1554         if( i_object ) vlc_object_release( p_vlc );
1555         return VLC_ENOOBJ;
1556     }
1557
1558     var_Get( p_input, "length", &val );
1559     vlc_object_release( p_input );
1560
1561     if( i_object ) vlc_object_release( p_vlc );
1562     return val.i_time  / 1000000L;
1563 }
1564
1565 /**
1566  * Play the input faster than realtime
1567  *
1568  * 2x, 4x, 8x faster than realtime
1569  * \note For some inputs, this will be impossible.
1570  *
1571  * \param i_object a vlc object id
1572  * \return the current speedrate
1573  */
1574 float VLC_SpeedFaster( int i_object )
1575 {
1576     input_thread_t *p_input;
1577     vlc_value_t val;
1578     vlc_t *p_vlc = vlc_current_object( i_object );
1579
1580     /* Check that the handle is valid */
1581     if( !p_vlc )
1582     {
1583         return VLC_ENOOBJ;
1584     }
1585
1586     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1587
1588     if( !p_input )
1589     {
1590         if( i_object ) vlc_object_release( p_vlc );
1591         return VLC_ENOOBJ;
1592     }
1593
1594     val.b_bool = VLC_TRUE;
1595     var_Set( p_input, "rate-faster", val );
1596     var_Get( p_input, "rate", &val );
1597     vlc_object_release( p_input );
1598
1599     if( i_object ) vlc_object_release( p_vlc );
1600     return val.f_float / INPUT_RATE_DEFAULT;
1601 }
1602
1603 /**
1604  * Play the input slower than realtime
1605  *
1606  * 1/2x, 1/4x, 1/8x slower than realtime
1607  * \note For some inputs, this will be impossible.
1608  *
1609  * \param i_object a vlc object id
1610  * \return the current speedrate
1611  */
1612 float VLC_SpeedSlower( int i_object )
1613 {
1614     input_thread_t *p_input;
1615     vlc_value_t val;
1616     vlc_t *p_vlc = vlc_current_object( i_object );
1617
1618     /* Check that the handle is valid */
1619     if( !p_vlc )
1620     {
1621         return VLC_ENOOBJ;
1622     }
1623
1624     p_input = vlc_object_find( p_vlc, VLC_OBJECT_INPUT, FIND_CHILD );
1625
1626     if( !p_input )
1627     {
1628         if( i_object ) vlc_object_release( p_vlc );
1629         return VLC_ENOOBJ;
1630     }
1631
1632     val.b_bool = VLC_TRUE;
1633     var_Set( p_input, "rate-slower", val );
1634     var_Get( p_input, "rate", &val );
1635     vlc_object_release( p_input );
1636
1637     if( i_object ) vlc_object_release( p_vlc );
1638     return val.f_float / INPUT_RATE_DEFAULT;
1639 }
1640
1641 /**
1642  * Return the current playlist item
1643  *
1644  * Returns the index of the playlistitem that is currently selected for play.
1645  * This is valid even if nothing is currently playing.
1646  *
1647  * \param i_object a vlc object id
1648  * \return the current index
1649  */
1650 int VLC_PlaylistIndex( int i_object )
1651 {
1652     int i_index;
1653     playlist_t * p_playlist;
1654     vlc_t *p_vlc = vlc_current_object( i_object );
1655
1656     /* Check that the handle is valid */
1657     if( !p_vlc )
1658     {
1659         return VLC_ENOOBJ;
1660     }
1661
1662     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1663
1664     if( !p_playlist )
1665     {
1666         if( i_object ) vlc_object_release( p_vlc );
1667         return VLC_ENOOBJ;
1668     }
1669
1670     i_index = p_playlist->i_index;
1671     vlc_object_release( p_playlist );
1672
1673     if( i_object ) vlc_object_release( p_vlc );
1674     return i_index;
1675 }
1676
1677 /**
1678  * Total amount of items in the playlist
1679  *
1680  * \param i_object a vlc object id
1681  * \return amount of playlist items
1682  */
1683 int VLC_PlaylistNumberOfItems( int i_object )
1684 {
1685     int i_size;
1686     playlist_t * p_playlist;
1687     vlc_t *p_vlc = vlc_current_object( i_object );
1688
1689     /* Check that the handle is valid */
1690     if( !p_vlc )
1691     {
1692         return VLC_ENOOBJ;
1693     }
1694
1695     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1696
1697     if( !p_playlist )
1698     {
1699         if( i_object ) vlc_object_release( p_vlc );
1700         return VLC_ENOOBJ;
1701     }
1702
1703     i_size = p_playlist->i_size;
1704     vlc_object_release( p_playlist );
1705
1706     if( i_object ) vlc_object_release( p_vlc );
1707     return i_size;
1708 }
1709
1710 /**
1711  * Next playlist item
1712  *
1713  * Skip to the next playlistitem and play it.
1714  *
1715  * \param i_object a vlc object id
1716  * \return VLC_SUCCESS on success
1717  */
1718 int VLC_PlaylistNext( int i_object )
1719 {
1720     playlist_t * p_playlist;
1721     vlc_t *p_vlc = vlc_current_object( i_object );
1722
1723     /* Check that the handle is valid */
1724     if( !p_vlc )
1725     {
1726         return VLC_ENOOBJ;
1727     }
1728
1729     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1730
1731     if( !p_playlist )
1732     {
1733         if( i_object ) vlc_object_release( p_vlc );
1734         return VLC_ENOOBJ;
1735     }
1736
1737     playlist_Next( p_playlist );
1738     vlc_object_release( p_playlist );
1739
1740     if( i_object ) vlc_object_release( p_vlc );
1741     return VLC_SUCCESS;
1742 }
1743
1744 /**
1745  * Previous playlist item
1746  *
1747  * Skip to the previous playlistitem and play it.
1748  *
1749  * \param i_object a vlc object id
1750  * \return VLC_SUCCESS on success
1751  */
1752 int VLC_PlaylistPrev( int i_object )
1753 {
1754     playlist_t * p_playlist;
1755     vlc_t *p_vlc = vlc_current_object( i_object );
1756
1757     /* Check that the handle is valid */
1758     if( !p_vlc )
1759     {
1760         return VLC_ENOOBJ;
1761     }
1762
1763     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1764
1765     if( !p_playlist )
1766     {
1767         if( i_object ) vlc_object_release( p_vlc );
1768         return VLC_ENOOBJ;
1769     }
1770
1771     playlist_Prev( p_playlist );
1772     vlc_object_release( p_playlist );
1773
1774     if( i_object ) vlc_object_release( p_vlc );
1775     return VLC_SUCCESS;
1776 }
1777
1778
1779 /*****************************************************************************
1780  * VLC_PlaylistClear: Empty the playlist
1781  *****************************************************************************/
1782 int VLC_PlaylistClear( int i_object )
1783 {
1784     int i_err;
1785     playlist_t * p_playlist;
1786     vlc_t *p_vlc = vlc_current_object( i_object );
1787
1788     /* Check that the handle is valid */
1789     if( !p_vlc )
1790     {
1791         return VLC_ENOOBJ;
1792     }
1793
1794     p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_CHILD );
1795
1796     if( !p_playlist )
1797     {
1798         if( i_object ) vlc_object_release( p_vlc );
1799         return VLC_ENOOBJ;
1800     }
1801
1802     i_err = playlist_Clear( p_playlist );
1803
1804     vlc_object_release( p_playlist );
1805
1806     if( i_object ) vlc_object_release( p_vlc );
1807     return i_err;
1808 }
1809
1810 /**
1811  * Change the volume
1812  *
1813  * \param i_object a vlc object id
1814  * \param i_volume something in a range from 0-200
1815  * \return the new volume (range 0-200 %)
1816  */
1817 int VLC_VolumeSet( int i_object, int i_volume )
1818 {
1819     audio_volume_t i_vol = 0;
1820     vlc_t *p_vlc = vlc_current_object( i_object );
1821
1822     /* Check that the handle is valid */
1823     if( !p_vlc )
1824     {
1825         return VLC_ENOOBJ;
1826     }
1827
1828     if( i_volume >= 0 && i_volume <= 200 )
1829     {
1830         i_vol = i_volume * AOUT_VOLUME_MAX / 200;
1831         aout_VolumeSet( p_vlc, i_vol );
1832     }
1833
1834     if( i_object ) vlc_object_release( p_vlc );
1835     return i_vol * 200 / AOUT_VOLUME_MAX;
1836 }
1837
1838 /**
1839  * Get the current volume
1840  *
1841  * Retrieve the current volume.
1842  *
1843  * \param i_object a vlc object id
1844  * \return the current volume (range 0-200 %)
1845  */
1846 int VLC_VolumeGet( int i_object )
1847 {
1848     audio_volume_t i_volume;
1849     vlc_t *p_vlc = vlc_current_object( i_object );
1850
1851     /* Check that the handle is valid */
1852     if( !p_vlc )
1853     {
1854         return VLC_ENOOBJ;
1855     }
1856
1857     aout_VolumeGet( p_vlc, &i_volume );
1858
1859     if( i_object ) vlc_object_release( p_vlc );
1860     return i_volume*200/AOUT_VOLUME_MAX;
1861 }
1862
1863 /**
1864  * Mute/Unmute the volume
1865  *
1866  * \param i_object a vlc object id
1867  * \return VLC_SUCCESS on success
1868  */
1869 int VLC_VolumeMute( int i_object )
1870 {
1871     vlc_t *p_vlc = vlc_current_object( i_object );
1872
1873     /* Check that the handle is valid */
1874     if( !p_vlc )
1875     {
1876         return VLC_ENOOBJ;
1877     }
1878
1879     aout_VolumeMute( p_vlc, NULL );
1880
1881     if( i_object ) vlc_object_release( p_vlc );
1882     return VLC_SUCCESS;
1883 }
1884
1885 /*****************************************************************************
1886  * VLC_FullScreen: toggle fullscreen mode
1887  *****************************************************************************/
1888 int VLC_FullScreen( int i_object )
1889 {
1890     vout_thread_t *p_vout;
1891     vlc_t *p_vlc = vlc_current_object( i_object );
1892
1893     if( !p_vlc )
1894     {
1895         return VLC_ENOOBJ;
1896     }
1897
1898     p_vout = vlc_object_find( p_vlc, VLC_OBJECT_VOUT, FIND_CHILD );
1899
1900     if( !p_vout )
1901     {
1902         if( i_object ) vlc_object_release( p_vlc );
1903         return VLC_ENOOBJ;
1904     }
1905
1906     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
1907     vlc_object_release( p_vout );
1908
1909     if( i_object ) vlc_object_release( p_vlc );
1910     return VLC_SUCCESS;
1911 }
1912
1913 /* following functions are local */
1914
1915 static void LocaleInit( void )
1916 {
1917     char *psz_charset;
1918
1919     if( !vlc_current_charset( &psz_charset ) )
1920     {
1921         char *psz_conv = psz_charset;
1922
1923         /*
1924          * Still allow non-ASCII characters when the locale is not set.
1925          * Western Europeans are being favored for historical reasons.
1926          */
1927         psz_conv = strcmp( psz_charset, "ASCII" )
1928             ? psz_charset
1929             : "ISO-8859-15";
1930
1931         vlc_mutex_init( p_libvlc, &libvlc.from_locale_lock );
1932         vlc_mutex_init( p_libvlc, &libvlc.to_locale_lock );
1933         libvlc.from_locale = vlc_iconv_open( "UTF-8", psz_charset );
1934         libvlc.to_locale = vlc_iconv_open( psz_charset, "UTF-8" );
1935         if( !libvlc.to_locale )
1936         {
1937             /* Not sure it is the right thing to do, but at least it
1938              doesn't make vlc crash with msvc ! */
1939             libvlc.to_locale = (vlc_iconv_t)(-1);
1940         }
1941     }
1942     else
1943         libvlc.from_locale = libvlc.to_locale = (vlc_iconv_t)(-1);
1944     free( psz_charset );
1945 }
1946
1947 static void LocaleDeinit( void )
1948 {
1949     if( libvlc.to_locale != (vlc_iconv_t)(-1) )
1950     {
1951         vlc_mutex_destroy( &libvlc.from_locale_lock );
1952         vlc_mutex_destroy( &libvlc.to_locale_lock );
1953         vlc_iconv_close( libvlc.from_locale );
1954         vlc_iconv_close( libvlc.to_locale );
1955     }
1956 }
1957
1958 /*****************************************************************************
1959  * SetLanguage: set the interface language.
1960  *****************************************************************************
1961  * We set the LC_MESSAGES locale category for interface messages and buttons,
1962  * as well as the LC_CTYPE category for string sorting and possible wide
1963  * character support.
1964  *****************************************************************************/
1965 static void SetLanguage ( char const *psz_lang )
1966 {
1967 #if defined( ENABLE_NLS ) \
1968      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) )
1969
1970     char *          psz_path;
1971 #if defined( SYS_DARWIN ) || defined ( WIN32 ) || defined( SYS_BEOS )
1972     char            psz_tmp[1024];
1973 #endif
1974
1975     if( psz_lang && !*psz_lang )
1976     {
1977 #   if defined( HAVE_LC_MESSAGES )
1978         setlocale( LC_MESSAGES, psz_lang );
1979 #   endif
1980         setlocale( LC_CTYPE, psz_lang );
1981     }
1982     else if( psz_lang )
1983     {
1984 #ifdef SYS_DARWIN
1985         /* I need that under Darwin, please check it doesn't disturb
1986          * other platforms. --Meuuh */
1987         setenv( "LANG", psz_lang, 1 );
1988
1989 #elif defined( SYS_BEOS ) || defined( WIN32 )
1990         /* We set LC_ALL manually because it is the only way to set
1991          * the language at runtime under eg. Windows. Beware that this
1992          * makes the environment unconsistent when libvlc is unloaded and
1993          * should probably be moved to a safer place like vlc.c. */
1994         static char psz_lcall[20];
1995         snprintf( psz_lcall, 19, "LC_ALL=%s", psz_lang );
1996         psz_lcall[19] = '\0';
1997         putenv( psz_lcall );
1998 #endif
1999
2000         setlocale( LC_ALL, psz_lang );
2001         /* many code paths assume that float numbers are formatted according
2002          * to the US standard (ie. with dot as decimal point), so we keep
2003          * C for LC_NUMERIC. */
2004         setlocale(LC_NUMERIC, "C" );
2005     }
2006
2007     /* Specify where to find the locales for current domain */
2008 #if !defined( SYS_DARWIN ) && !defined( WIN32 ) && !defined( SYS_BEOS )
2009     psz_path = LOCALEDIR;
2010 #else
2011     snprintf( psz_tmp, sizeof(psz_tmp), "%s/%s", libvlc.psz_vlcpath,
2012               "locale" );
2013     psz_path = psz_tmp;
2014 #endif
2015     if( !bindtextdomain( PACKAGE_NAME, psz_path ) )
2016     {
2017         fprintf( stderr, "warning: couldn't bind domain %s in directory %s\n",
2018                  PACKAGE_NAME, psz_path );
2019     }
2020
2021     /* Set the default domain */
2022     textdomain( PACKAGE_NAME );
2023     bind_textdomain_codeset( PACKAGE_NAME, "UTF-8" );
2024 #endif
2025 }
2026
2027 /*****************************************************************************
2028  * GetFilenames: parse command line options which are not flags
2029  *****************************************************************************
2030  * Parse command line for input files as well as their associated options.
2031  * An option always follows its associated input and begins with a ":".
2032  *****************************************************************************/
2033 static int GetFilenames( vlc_t *p_vlc, int i_argc, char *ppsz_argv[] )
2034 {
2035     int i_opt, i_options;
2036
2037     /* We assume that the remaining parameters are filenames
2038      * and their input options */
2039     for( i_opt = i_argc - 1; i_opt >= optind; i_opt-- )
2040     {
2041         const char *psz_target;
2042         i_options = 0;
2043
2044         /* Count the input options */
2045         while( *ppsz_argv[ i_opt ] == ':' && i_opt > optind )
2046         {
2047             i_options++;
2048             i_opt--;
2049         }
2050
2051         /* TODO: write an internal function of this one, to avoid
2052          *       unnecessary lookups. */
2053         /* FIXME: should we convert options to UTF-8 as well ?? */
2054         psz_target = FromLocale( ppsz_argv[ i_opt ] );
2055         VLC_AddTarget( p_vlc->i_object_id, psz_target,
2056                        (char const **)( i_options ? &ppsz_argv[i_opt + 1] :
2057                                         NULL ), i_options,
2058                        PLAYLIST_INSERT, 0 );
2059         LocaleFree( psz_target );
2060     }
2061
2062     return VLC_SUCCESS;
2063 }
2064
2065 /*****************************************************************************
2066  * Help: print program help
2067  *****************************************************************************
2068  * Print a short inline help. Message interface is initialized at this stage.
2069  *****************************************************************************/
2070 static void Help( vlc_t *p_this, char const *psz_help_name )
2071 {
2072 #ifdef WIN32
2073     ShowConsole();
2074 #endif
2075
2076     if( psz_help_name && !strcmp( psz_help_name, "help" ) )
2077     {
2078         fprintf( stdout, VLC_USAGE, p_this->psz_object_name );
2079         Usage( p_this, "help" );
2080         Usage( p_this, "main" );
2081     }
2082     else if( psz_help_name && !strcmp( psz_help_name, "longhelp" ) )
2083     {
2084         fprintf( stdout, VLC_USAGE, p_this->psz_object_name );
2085         Usage( p_this, NULL );
2086     }
2087     else if( psz_help_name )
2088     {
2089         Usage( p_this, psz_help_name );
2090     }
2091
2092 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
2093     PauseConsole();
2094 #endif
2095 }
2096
2097 /*****************************************************************************
2098  * Usage: print module usage
2099  *****************************************************************************
2100  * Print a short inline help. Message interface is initialized at this stage.
2101  *****************************************************************************/
2102 static void Usage( vlc_t *p_this, char const *psz_module_name )
2103 {
2104 #define FORMAT_STRING "  %s --%s%s%s%s%s%s%s "
2105     /* short option ------'    |     | | | |  | |
2106      * option name ------------'     | | | |  | |
2107      * <bra -------------------------' | | |  | |
2108      * option type or "" --------------' | |  | |
2109      * ket> -----------------------------' |  | |
2110      * padding spaces ---------------------'  | |
2111      * comment -------------------------------' |
2112      * comment suffix --------------------------'
2113      *
2114      * The purpose of having bra and ket is that we might i18n them as well.
2115      */
2116 #define LINE_START 8
2117 #define PADDING_SPACES 25
2118     vlc_list_t *p_list;
2119     module_t *p_parser;
2120     module_config_t *p_item;
2121     char psz_spaces_text[PADDING_SPACES+LINE_START+1];
2122     char psz_spaces_longtext[LINE_START+3];
2123     char psz_format[sizeof(FORMAT_STRING)];
2124     char psz_buffer[10000];
2125     char psz_short[4];
2126     int i_index;
2127     int i_width = ConsoleWidth() - (PADDING_SPACES+LINE_START+1);
2128     vlc_bool_t b_advanced = config_GetInt( p_this, "advanced" );
2129     vlc_bool_t b_description;
2130
2131     memset( psz_spaces_text, ' ', PADDING_SPACES+LINE_START );
2132     psz_spaces_text[PADDING_SPACES+LINE_START] = '\0';
2133     memset( psz_spaces_longtext, ' ', LINE_START+2 );
2134     psz_spaces_longtext[LINE_START+2] = '\0';
2135
2136     strcpy( psz_format, FORMAT_STRING );
2137
2138     /* List all modules */
2139     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
2140
2141     /* Enumerate the config for each module */
2142     for( i_index = 0; i_index < p_list->i_count; i_index++ )
2143     {
2144         vlc_bool_t b_help_module;
2145
2146         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
2147
2148         if( psz_module_name && strcmp( psz_module_name,
2149                                        p_parser->psz_object_name ) )
2150         {
2151             continue;
2152         }
2153
2154         /* Ignore modules without config options */
2155         if( !p_parser->i_config_items )
2156         {
2157             continue;
2158         }
2159
2160         /* Ignore modules with only advanced config options if requested */
2161         if( !b_advanced )
2162         {
2163             for( p_item = p_parser->p_config;
2164                  p_item->i_type != CONFIG_HINT_END;
2165                  p_item++ )
2166             {
2167                 if( (p_item->i_type & CONFIG_ITEM) &&
2168                     !p_item->b_advanced ) break;
2169             }
2170             if( p_item->i_type == CONFIG_HINT_END ) continue;
2171         }
2172
2173         /* Print name of module */
2174         if( strcmp( "main", p_parser->psz_object_name ) )
2175         fprintf( stdout, "\n %s\n", p_parser->psz_longname );
2176
2177         b_help_module = !strcmp( "help", p_parser->psz_object_name );
2178
2179         /* Print module options */
2180         for( p_item = p_parser->p_config;
2181              p_item->i_type != CONFIG_HINT_END;
2182              p_item++ )
2183         {
2184             char *psz_text, *psz_spaces = psz_spaces_text;
2185             char *psz_bra = NULL, *psz_type = NULL, *psz_ket = NULL;
2186             char *psz_suf = "", *psz_prefix = NULL;
2187             signed int i;
2188
2189             /* Skip deprecated options */
2190             if( p_item->psz_current )
2191             {
2192                 continue;
2193             }
2194             /* Skip advanced options if requested */
2195             if( p_item->b_advanced && !b_advanced )
2196             {
2197                 continue;
2198             }
2199
2200             switch( p_item->i_type )
2201             {
2202             case CONFIG_HINT_CATEGORY:
2203             case CONFIG_HINT_USAGE:
2204                 if( !strcmp( "main", p_parser->psz_object_name ) )
2205                 fprintf( stdout, "\n %s\n", p_item->psz_text );
2206                 break;
2207
2208             case CONFIG_ITEM_STRING:
2209             case CONFIG_ITEM_FILE:
2210             case CONFIG_ITEM_DIRECTORY:
2211             case CONFIG_ITEM_MODULE: /* We could also have "=<" here */
2212             case CONFIG_ITEM_MODULE_CAT:
2213             case CONFIG_ITEM_MODULE_LIST:
2214             case CONFIG_ITEM_MODULE_LIST_CAT:
2215                 psz_bra = " <"; psz_type = _("string"); psz_ket = ">";
2216
2217                 if( p_item->ppsz_list )
2218                 {
2219                     psz_bra = " {";
2220                     psz_type = psz_buffer;
2221                     psz_type[0] = '\0';
2222                     for( i = 0; p_item->ppsz_list[i]; i++ )
2223                     {
2224                         if( i ) strcat( psz_type, "," );
2225                         strcat( psz_type, p_item->ppsz_list[i] );
2226                     }
2227                     psz_ket = "}";
2228                 }
2229                 break;
2230             case CONFIG_ITEM_INTEGER:
2231             case CONFIG_ITEM_KEY: /* FIXME: do something a bit more clever */
2232                 psz_bra = " <"; psz_type = _("integer"); psz_ket = ">";
2233
2234                 if( p_item->i_list )
2235                 {
2236                     psz_bra = " {";
2237                     psz_type = psz_buffer;
2238                     psz_type[0] = '\0';
2239                     for( i = 0; p_item->ppsz_list_text[i]; i++ )
2240                     {
2241                         if( i ) strcat( psz_type, ", " );
2242                         sprintf( psz_type + strlen(psz_type), "%i (%s)",
2243                                  p_item->pi_list[i],
2244                                  p_item->ppsz_list_text[i] );
2245                     }
2246                     psz_ket = "}";
2247                 }
2248                 break;
2249             case CONFIG_ITEM_FLOAT:
2250                 psz_bra = " <"; psz_type = _("float"); psz_ket = ">";
2251                 break;
2252             case CONFIG_ITEM_BOOL:
2253                 psz_bra = ""; psz_type = ""; psz_ket = "";
2254                 if( !b_help_module )
2255                 {
2256                     psz_suf = p_item->i_value ? _(" (default enabled)") :
2257                                                 _(" (default disabled)");
2258                 }
2259                 break;
2260             }
2261
2262             if( !psz_type )
2263             {
2264                 continue;
2265             }
2266
2267             /* Add short option if any */
2268             if( p_item->i_short )
2269             {
2270                 sprintf( psz_short, "-%c,", p_item->i_short );
2271             }
2272             else
2273             {
2274                 strcpy( psz_short, "   " );
2275             }
2276
2277             i = PADDING_SPACES - strlen( p_item->psz_name )
2278                  - strlen( psz_bra ) - strlen( psz_type )
2279                  - strlen( psz_ket ) - 1;
2280
2281             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
2282             {
2283                 psz_prefix =  ", --no-";
2284                 i -= strlen( p_item->psz_name ) + strlen( psz_prefix );
2285             }
2286
2287             if( i < 0 )
2288             {
2289                 psz_spaces[0] = '\n';
2290                 i = 0;
2291             }
2292             else
2293             {
2294                 psz_spaces[i] = '\0';
2295             }
2296
2297             if( p_item->i_type == CONFIG_ITEM_BOOL && !b_help_module )
2298             {
2299                 fprintf( stdout, psz_format, psz_short, p_item->psz_name,
2300                          psz_prefix, p_item->psz_name, psz_bra, psz_type,
2301                          psz_ket, psz_spaces );
2302             }
2303             else
2304             {
2305                 fprintf( stdout, psz_format, psz_short, p_item->psz_name,
2306                          "", "", psz_bra, psz_type, psz_ket, psz_spaces );
2307             }
2308
2309             psz_spaces[i] = ' ';
2310
2311             /* We wrap the rest of the output */
2312             sprintf( psz_buffer, "%s%s", p_item->psz_text, psz_suf );
2313             b_description = config_GetInt( p_this, "help-verbose" );
2314
2315  description:
2316             psz_text = psz_buffer;
2317             while( *psz_text )
2318             {
2319                 char *psz_parser, *psz_word;
2320                 size_t i_end = strlen( psz_text );
2321
2322                 /* If the remaining text fits in a line, print it. */
2323                 if( i_end <= (size_t)i_width )
2324                 {
2325                     fprintf( stdout, "%s\n", psz_text );
2326                     break;
2327                 }
2328
2329                 /* Otherwise, eat as many words as possible */
2330                 psz_parser = psz_text;
2331                 do
2332                 {
2333                     psz_word = psz_parser;
2334                     psz_parser = strchr( psz_word, ' ' );
2335                     /* If no space was found, we reached the end of the text
2336                      * block; otherwise, we skip the space we just found. */
2337                     psz_parser = psz_parser ? psz_parser + 1
2338                                             : psz_text + i_end;
2339
2340                 } while( psz_parser - psz_text <= i_width );
2341
2342                 /* We cut a word in one of these cases:
2343                  *  - it's the only word in the line and it's too long.
2344                  *  - we used less than 80% of the width and the word we are
2345                  *    going to wrap is longer than 40% of the width, and even
2346                  *    if the word would have fit in the next line. */
2347                 if( psz_word == psz_text
2348                      || ( psz_word - psz_text < 80 * i_width / 100
2349                            && psz_parser - psz_word > 40 * i_width / 100 ) )
2350                 {
2351                     char c = psz_text[i_width];
2352                     psz_text[i_width] = '\0';
2353                     fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
2354                     psz_text += i_width;
2355                     psz_text[0] = c;
2356                 }
2357                 else
2358                 {
2359                     psz_word[-1] = '\0';
2360                     fprintf( stdout, "%s\n%s", psz_text, psz_spaces );
2361                     psz_text = psz_word;
2362                 }
2363             }
2364
2365             if( b_description && p_item->psz_longtext )
2366             {
2367                 sprintf( psz_buffer, "%s%s", p_item->psz_longtext, psz_suf );
2368                 b_description = VLC_FALSE;
2369                 psz_spaces = psz_spaces_longtext;
2370                 fprintf( stdout, "%s", psz_spaces );
2371                 goto description;
2372             }
2373         }
2374     }
2375
2376     /* Release the module list */
2377     vlc_list_release( p_list );
2378 }
2379
2380 /*****************************************************************************
2381  * ListModules: list the available modules with their description
2382  *****************************************************************************
2383  * Print a list of all available modules (builtins and plugins) and a short
2384  * description for each one.
2385  *****************************************************************************/
2386 static void ListModules( vlc_t *p_this )
2387 {
2388     vlc_list_t *p_list;
2389     module_t *p_parser;
2390     char psz_spaces[22];
2391     int i_index;
2392
2393     memset( psz_spaces, ' ', 22 );
2394
2395 #ifdef WIN32
2396     ShowConsole();
2397 #endif
2398
2399     /* List all modules */
2400     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
2401
2402     /* Enumerate each module */
2403     for( i_index = 0; i_index < p_list->i_count; i_index++ )
2404     {
2405         int i;
2406
2407         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
2408
2409         /* Nasty hack, but right now I'm too tired to think about a nice
2410          * solution */
2411         i = 22 - strlen( p_parser->psz_object_name ) - 1;
2412         if( i < 0 ) i = 0;
2413         psz_spaces[i] = 0;
2414
2415         fprintf( stdout, "  %s%s %s\n", p_parser->psz_object_name,
2416                          psz_spaces, p_parser->psz_longname );
2417
2418         psz_spaces[i] = ' ';
2419     }
2420
2421     vlc_list_release( p_list );
2422
2423 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
2424     PauseConsole();
2425 #endif
2426 }
2427
2428 /*****************************************************************************
2429  * Version: print complete program version
2430  *****************************************************************************
2431  * Print complete program version and build number.
2432  *****************************************************************************/
2433 static void Version( void )
2434 {
2435 #ifdef WIN32
2436     ShowConsole();
2437 #endif
2438
2439     fprintf( stdout, _("VLC version %s\n"), VLC_Version() );
2440     fprintf( stdout, _("Compiled by %s@%s.%s\n"),
2441              VLC_CompileBy(), VLC_CompileHost(), VLC_CompileDomain() );
2442     fprintf( stdout, _("Compiler: %s\n"), VLC_Compiler() );
2443     if( strcmp( VLC_Changeset(), "exported" ) )
2444         fprintf( stdout, _("Based upon svn changeset [%s]\n"),
2445                  VLC_Changeset() );
2446     fprintf( stdout, LICENSE_MSG );
2447
2448 #ifdef WIN32        /* Pause the console because it's destroyed when we exit */
2449     PauseConsole();
2450 #endif
2451 }
2452
2453 /*****************************************************************************
2454  * ShowConsole: On Win32, create an output console for debug messages
2455  *****************************************************************************
2456  * This function is useful only on Win32.
2457  *****************************************************************************/
2458 #ifdef WIN32 /*  */
2459 static void ShowConsole( void )
2460 {
2461 #   ifndef UNDER_CE
2462     FILE *f_help;
2463
2464     if( getenv( "PWD" ) && getenv( "PS1" ) ) return; /* cygwin shell */
2465
2466     AllocConsole();
2467
2468     freopen( "CONOUT$", "w", stderr );
2469     freopen( "CONIN$", "r", stdin );
2470
2471     if( (f_help = fopen( "vlc-help.txt", "wt" )) )
2472     {
2473         fclose( f_help );
2474         freopen( "vlc-help.txt", "wt", stdout );
2475         fprintf( stderr, _("\nDumped content to vlc-help.txt file.\n") );
2476     }
2477
2478     else freopen( "CONOUT$", "w", stdout );
2479
2480 #   endif
2481 }
2482 #endif
2483
2484 /*****************************************************************************
2485  * PauseConsole: On Win32, wait for a key press before closing the console
2486  *****************************************************************************
2487  * This function is useful only on Win32.
2488  *****************************************************************************/
2489 #ifdef WIN32 /*  */
2490 static void PauseConsole( void )
2491 {
2492 #   ifndef UNDER_CE
2493
2494     if( getenv( "PWD" ) && getenv( "PS1" ) ) return; /* cygwin shell */
2495
2496     fprintf( stderr, _("\nPress the RETURN key to continue...\n") );
2497     getchar();
2498     fclose( stdout );
2499
2500 #   endif
2501 }
2502 #endif
2503
2504 /*****************************************************************************
2505  * ConsoleWidth: Return the console width in characters
2506  *****************************************************************************
2507  * We use the stty shell command to get the console width; if this fails or
2508  * if the width is less than 80, we default to 80.
2509  *****************************************************************************/
2510 static int ConsoleWidth( void )
2511 {
2512     int i_width = 80;
2513
2514 #ifndef WIN32
2515     char buf[20], *psz_parser;
2516     FILE *file;
2517     int i_ret;
2518
2519     file = popen( "stty size 2>/dev/null", "r" );
2520     if( file )
2521     {
2522         i_ret = fread( buf, 1, 20, file );
2523         if( i_ret > 0 )
2524         {
2525             buf[19] = '\0';
2526             psz_parser = strchr( buf, ' ' );
2527             if( psz_parser )
2528             {
2529                 i_ret = atoi( psz_parser + 1 );
2530                 if( i_ret >= 80 )
2531                 {
2532                     i_width = i_ret;
2533                 }
2534             }
2535         }
2536
2537         pclose( file );
2538     }
2539 #endif
2540
2541     return i_width;
2542 }
2543
2544 static int VerboseCallback( vlc_object_t *p_this, const char *psz_variable,
2545                      vlc_value_t old_val, vlc_value_t new_val, void *param)
2546 {
2547     vlc_t *p_vlc = (vlc_t *)p_this;
2548
2549     if( new_val.i_int >= -1 )
2550     {
2551         p_vlc->p_libvlc->i_verbose = __MIN( new_val.i_int, 2 );
2552     }
2553     return VLC_SUCCESS;
2554 }
2555
2556 /*****************************************************************************
2557  * InitDeviceValues: initialize device values
2558  *****************************************************************************
2559  * This function inits the dvd, vcd and cd-audio values
2560  *****************************************************************************/
2561 static void InitDeviceValues( vlc_t *p_vlc )
2562 {
2563 #ifdef HAVE_HAL
2564     LibHalContext * ctx;
2565     int i, i_devices;
2566     char **devices;
2567     char *block_dev;
2568     dbus_bool_t b_dvd;
2569     DBusConnection *p_connection;
2570     DBusError       error;
2571
2572 #ifdef HAVE_HAL_1
2573     ctx =  libhal_ctx_new();
2574     if( !ctx ) return;
2575     dbus_error_init( &error );
2576     p_connection = dbus_bus_get ( DBUS_BUS_SYSTEM, &error );
2577     if( dbus_error_is_set( &error ) )
2578     {
2579         dbus_error_free( &error );
2580         return;
2581     }
2582     libhal_ctx_set_dbus_connection( ctx, p_connection );
2583     if( libhal_ctx_init( ctx, &error ) )
2584 #else
2585     if( ( ctx = hal_initialize( NULL, FALSE ) ) )
2586 #endif
2587     {
2588 #ifdef HAVE_HAL_1
2589         if( ( devices = libhal_get_all_devices( ctx, &i_devices, NULL ) ) )
2590 #else
2591         if( ( devices = hal_get_all_devices( ctx, &i_devices ) ) )
2592 #endif
2593         {
2594             for( i = 0; i < i_devices; i++ )
2595             {
2596 #ifdef HAVE_HAL_1
2597                 if( !libhal_device_property_exists( ctx, devices[i],
2598                                                 "storage.cdrom.dvd", NULL ) )
2599 #else
2600                 if( !hal_device_property_exists( ctx, devices[ i ],
2601                                                 "storage.cdrom.dvd" ) )
2602 #endif
2603                 {
2604                     continue;
2605                 }
2606 #ifdef HAVE_HAL_1
2607                 b_dvd = libhal_device_get_property_bool( ctx, devices[ i ],
2608                                                  "storage.cdrom.dvd", NULL  );
2609                 block_dev = libhal_device_get_property_string( ctx,
2610                                 devices[ i ], "block.device" , NULL );
2611 #else
2612                 b_dvd = hal_device_get_property_bool( ctx, devices[ i ],
2613                                                       "storage.cdrom.dvd" );
2614                 block_dev = hal_device_get_property_string( ctx, devices[ i ],
2615                                                             "block.device" );
2616 #endif
2617                 if( b_dvd )
2618                 {
2619                     config_PutPsz( p_vlc, "dvd", block_dev );
2620                 }
2621
2622                 config_PutPsz( p_vlc, "vcd", block_dev );
2623                 config_PutPsz( p_vlc, "cd-audio", block_dev );
2624 #ifdef HAVE_HAL_1
2625                 libhal_free_string( block_dev );
2626 #else
2627                 hal_free_string( block_dev );
2628 #endif
2629             }
2630 #ifdef HAVE_HAL_1
2631             libhal_free_string_array( devices );
2632 #else
2633             hal_free_string_array( devices );
2634 #endif
2635         }
2636
2637 #ifdef HAVE_HAL_1
2638         libhal_ctx_shutdown( ctx, NULL );
2639 #else
2640         hal_shutdown( ctx );
2641 #endif
2642     }
2643     else
2644     {
2645         msg_Warn( p_vlc, "Unable to get HAL device properties" );
2646     }
2647 #endif
2648 }
2649
2650 /*****************************************************************************
2651  * FromLocale: converts a locale string to UTF-8
2652  *****************************************************************************/
2653 char *FromLocale( const char *locale )
2654 {
2655     if( locale == NULL )
2656         return NULL;
2657
2658     if( libvlc.from_locale != (vlc_iconv_t)(-1) )
2659     {
2660         char *iptr = (char *)locale, *output, *optr;
2661         size_t inb, outb;
2662
2663         /*
2664          * We are not allowed to modify the locale pointer, even if we cast it
2665          * to non-const.
2666          */
2667         inb = strlen( locale );
2668         outb = inb * 6 + 1;
2669
2670         /* FIXME: I'm not sure about the value for the multiplication
2671          * (for western people, multiplication by 3 (Latin9) is sufficient) */
2672         optr = output = calloc( outb , 1);
2673
2674         vlc_mutex_lock( &libvlc.from_locale_lock );
2675         vlc_iconv( libvlc.from_locale, NULL, NULL, NULL, NULL );
2676
2677         while( vlc_iconv( libvlc.from_locale, &iptr, &inb, &optr, &outb )
2678                                                                == (size_t)-1 )
2679         {
2680             *optr = '?';
2681             optr++;
2682             iptr++;
2683             vlc_iconv( libvlc.from_locale, NULL, NULL, NULL, NULL );
2684         }
2685         vlc_mutex_unlock( &libvlc.from_locale_lock );
2686
2687         return realloc( output, strlen( output ) + 1 );
2688     }
2689     return (char *)locale;
2690 }
2691
2692 /*****************************************************************************
2693  * ToLocale: converts an UTF-8 string to locale
2694  *****************************************************************************/
2695 char *ToLocale( const char *utf8 )
2696 {
2697     if( utf8 == NULL )
2698         return NULL;
2699
2700     if( libvlc.to_locale != (vlc_iconv_t)(-1) )
2701     {
2702         char *iptr = (char *)utf8, *output, *optr;
2703         size_t inb, outb;
2704
2705         /*
2706          * We are not allowed to modify the locale pointer, even if we cast it
2707          * to non-const.
2708          */
2709         inb = strlen( utf8 );
2710         /* FIXME: I'm not sure about the value for the multiplication
2711          * (for western people, multiplication is not needed) */
2712         outb = inb * 2 + 1;
2713
2714         optr = output = calloc( outb, 1 );
2715         vlc_mutex_lock( &libvlc.to_locale_lock );
2716         vlc_iconv( libvlc.to_locale, NULL, NULL, NULL, NULL );
2717
2718         while( vlc_iconv( libvlc.to_locale, &iptr, &inb, &optr, &outb )
2719                                                                == (size_t)-1 )
2720         {
2721             *optr = '?'; /* should not happen, and yes, it sucks */
2722             optr++;
2723             iptr++;
2724             vlc_iconv( libvlc.to_locale, NULL, NULL, NULL, NULL );
2725         }
2726         vlc_mutex_unlock( &libvlc.to_locale_lock );
2727
2728         return realloc( output, strlen( output ) + 1 );
2729     }
2730     return (char *)utf8;
2731 }
2732
2733 void LocaleFree( const char *str )
2734 {
2735     if( ( str != NULL ) && ( libvlc.to_locale != (vlc_iconv_t)(-1) ) )
2736         free( (char *)str );
2737 }