Changeset 13a1c6b8b8c82e1234d11b8b90c9ceb488ee55f0

Show
Ignore:
Timestamp:
31/05/08 21:30:46 (4 months ago)
Author:
Rémi Denis-Courmont <rdenis@simphalempin.com>
git-committer:
Rémi Denis-Courmont <rdenis@simphalempin.com> 1212262246 +0300
git-parent:

[5ba2255e622499a3bb545e89c84a675f0adde07f]

git-author:
Rémi Denis-Courmont <rdenis@simphalempin.com> 1212262246 +0300
Message:

Remove VLC_* dead APIs

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • po/POTFILES.in

    r5181ef7 r13a1c6b  
    1515include/vlc_codec_synchro.h 
    1616include/vlc_common.h 
    17 include/vlc/common.h 
    1817include/vlc_config_cat.h 
    1918include/vlc_config.h 
     
    134133src/interface/intf_eject.c 
    135134src/libvlc.c 
    136 src/libvlc-common.c 
    137135src/libvlc.h 
    138136src/libvlc-module.c 
  • src/Makefile.am

    ra20c35e r13a1c6b  
    265265SOURCES_libvlc_common = \ 
    266266    libvlc.c \ 
    267     libvlc-common.c \ 
    268267    libvlc.h \ 
    269268    libvlc-module.c \ 
  • src/libvlc.c

    <
    rd666030 r13a1c6b  
    11/***************************************************************************** 
    2  * libvlc.c: Implementation of the old libvlc API 
     2 * libvlc.c: libvlc instances creation and deletion, interfaces handling 
    33 ***************************************************************************** 
    4  * Copyright (C) 1998-2007 the VideoLAN team 
     4 * Copyright (C) 1998-2008 the VideoLAN team 
    55 * $Id$ 
    66 * 
     
    2626 *****************************************************************************/ 
    2727 
    28 /***************************************************************************** 
    29  * Pretend we are a builtin module 
    30  *****************************************************************************/ 
    31 #define MODULE_NAME main 
    32 #define MODULE_PATH main 
    33 #define __BUILTIN__ 
     28/** \file 
     29 * This file contains functions to create and destroy libvlc instances 
     30 */ 
    3431 
    3532/***************************************************************************** 
     
    4138 
    4239#include <vlc_common.h> 
    43  
    4440#include "control/libvlc_internal.h" 
     41#include <vlc_input.h> 
     42 
     43#include "modules/modules.h" 
     44#include "config/configuration.h" 
     45#include "interface/interface.h" 
     46 
     47#include <errno.h>                                                 /* ENOMEM */ 
     48#include <stdio.h>                                              /* sprintf() */ 
     49#include <string.h> 
     50#include <stdlib.h>                                                /* free() */ 
     51 
     52#ifndef WIN32 
     53#   include <netinet/in.h>                            /* BSD: struct in_addr */ 
     54#endif 
     55 
     56#ifdef HAVE_UNISTD_H 
     57#   include <unistd.h> 
     58#elif defined( WIN32 ) && !defined( UNDER_CE ) 
     59#   include <io.h> 
     60#endif 
     61 
     62#ifdef WIN32                       /* optind, getopt(), included in unistd.h */ 
     63#   include "extras/getopt.h" 
     64#endif 
     65 
     66#ifdef HAVE_LOCALE_H 
     67#   include <locale.h> 
     68#endif 
     69 
     70#ifdef HAVE_DBUS_3 
     71/* used for one-instance mode */ 
     72#   include <dbus/dbus.h> 
     73#endif 
     74 
     75#ifdef HAVE_HAL 
     76#   include <hal/libhal.h> 
     77#endif 
     78 
     79#include <vlc_playlist.h> 
     80#include <vlc_interface.h> 
     81 
     82#include <vlc_aout.h> 
     83#include "audio_output/aout_internal.h" 
     84 
     85#include <vlc_vout.h> 
     86 
     87#include <vlc_sout.h> 
     88#include "stream_output/stream_output.h" 
     89 
     90#include <vlc_charset.h> 
     91 
    4592#include "libvlc.h" 
    4693 
    47 #include <vlc_playlist.h> 
    48  
    49 #include <vlc_aout.h> 
    50 #include <vlc_vout.h> 
    51  
    52 #define LIBVLC_FUNC \ 
    53     libvlc_int_t * p_libvlc = vlc_current_object( i_object ); \ 
    54     if( !p_libvlc ) return VLC_ENOOBJ; 
    55 #define LIBVLC_FUNC_END \ 
    56     if( i_object ) vlc_object_release( p_libvlc ); 
    57  
     94#include "playlist/playlist_internal.h" 
     95 
     96#include <vlc_vlm.h> 
     97 
     98#include <assert.h> 
    5899 
    59100/***************************************************************************** 
    60  * VLC_VariableSet: set a "safe" vlc variable 
     101 * The evil global variables. We handle them with care, don't worry. 
    61102 *****************************************************************************/ 
    62 int VLC_VariableSet( int i_object, char const *psz_var, vlc_value_t value ) 
     103static libvlc_int_t *    p_static_vlc = NULL; 
     104static unsigned          i_instances = 0; 
     105 
     106static bool b_daemon = false; 
     107 
     108/***************************************************************************** 
     109 * Local prototypes 
     110 *****************************************************************************/ 
     111#if defined( ENABLE_NLS ) && (defined (__APPLE__) || defined (WIN32)) && \ 
     112    ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) 
     113static void SetLanguage   ( char const * ); 
     114#endif 
     115static inline int LoadMessages (void); 
     116static int  GetFilenames  ( libvlc_int_t *, int, const char *[] ); 
     117static void Help          ( libvlc_int_t *, char const *psz_help_name ); 
     118static void Usage         ( libvlc_int_t *, char const *psz_module_name ); 
     119static void ListModules   ( libvlc_int_t *, bool ); 
     120static void Version       ( void ); 
     121 
     122#ifdef WIN32 
     123static void ShowConsole   ( bool ); 
     124static void PauseConsole  ( void ); 
     125#endif 
     126static int  ConsoleWidth  ( void ); 
     127 
     128static int  VerboseCallback( vlc_object_t *, char const *, 
     129                             vlc_value_t, vlc_value_t, void * ); 
     130 
     131static void InitDeviceValues( libvlc_int_t * ); 
     132 
     133/***************************************************************************** 
     134 * vlc_current_object: return the current object. 
     135 ***************************************************************************** 
     136 * If i_object is non-zero, return the corresponding object. Otherwise, 
     137 * return the statically allocated p_vlc object. 
     138 *****************************************************************************/ 
     139libvlc_int_t * vlc_current_object( int i_object ) 
    63140{ 
    64     int i_ret; 
    65     LIBVLC_FUNC; 
    66  
    67     /* FIXME: Temporary hack for Mozilla, if variable starts with conf:: then 
    68      * we handle it as a configuration variable. Don't tell Gildas :) -- sam */ 
    69     if( !strncmp( psz_var, "conf::", 6 ) ) 
    70     { 
    71         module_config_t *p_item; 
    72         char const *psz_newvar = psz_var + 6; 
    73  
    74         p_item = config_FindConfig( VLC_OBJECT(p_libvlc), psz_newvar ); 
    75  
    76         if( p_item ) 
    77         { 
    78             /* VLC_VariableSet is only used from the browser plugins, so we 
    79              *  can pretty much assume that the input is _not_ trusted. */ 
    80             if( !p_item->b_safe ) 
    81                 return VLC_EGENERIC; 
    82  
    83             switch( p_item->i_type ) 
    84             { 
    85                 case CONFIG_ITEM_BOOL: 
    86                     config_PutInt( p_libvlc, psz_newvar, value.b_bool ); 
    87                     break; 
    88                 case CONFIG_ITEM_INTEGER: 
    89                     config_PutInt( p_libvlc, psz_newvar, value.i_int ); 
    90                     break; 
    91                 case CONFIG_ITEM_FLOAT: 
    92                     config_PutFloat( p_libvlc, psz_newvar, value.f_float ); 
    93                     break; 
    94                 default: 
    95                     config_PutPsz( p_libvlc, psz_newvar, value.psz_string ); 
    96                     break; 
    97             } 
    98             if( i_object ) vlc_object_release( p_libvlc ); 
    99             return VLC_SUCCESS; 
    100         } 
    101     } 
    102     /* EXPLICIT HACK (this is the legacy API anyway): 
    103      * VLC_VariableSet is only used from the browser plugins, so we 
    104      *  can pretty much assume that the input is _not_ trusted. */ 
    105     module_config_t *p_item; 
    106     p_item = config_FindConfig( VLC_OBJECT(p_libvlc), psz_var ); 
    107     if( !p_item ) 
    108         return VLC_ENOVAR; 
    109     if( !p_item->b_safe ) 
     141    return i_object ? vlc_object_get( i_object ) : p_static_vlc; 
     142
     143 
     144 
     145/** 
     146 * Allocate a libvlc instance, initialize global data if needed 
     147 * It also initializes the threading system 
     148 */ 
     149libvlc_int_t * libvlc_InternalCreate( void ) 
     150
     151    libvlc_int_t *p_libvlc; 
     152    libvlc_priv_t *priv; 
     153    char *psz_env = NULL; 
     154 
     155    /* vlc_threads_init *must* be the first internal call! No other call is 
     156     * allowed before the thread system has been initialized. */ 
     157    if (vlc_threads_init ()) 
     158        return NULL; 
     159 
     160    libvlc_global_data_t *p_libvlc_global = vlc_global(); 
     161    /* Now that the thread system is initialized, we don't have much, but 
     162     * at least we have variables */ 
     163    vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); 
     164    if( i_instances == 0 ) 
     165    { 
     166        /* Guess what CPU we have */ 
     167        cpu_flags = CPUCapabilities(); 
     168       /* The module bank will be initialized later */ 
     169        p_libvlc_global->p_module_bank = NULL; 
     170    } 
     171 
     172    /* Allocate a libvlc instance object */ 
     173    p_libvlc = vlc_custom_create( VLC_OBJECT(p_libvlc_global), 
     174                                  sizeof (*p_libvlc) + sizeof (libvlc_priv_t), 
     175                                  VLC_OBJECT_LIBVLC, "libvlc" ); 
     176    if( p_libvlc != NULL ) 
     177        i_instances++; 
     178    vlc_mutex_unlock( lock ); 
     179 
     180    if( p_libvlc == NULL ) 
     181        return NULL; 
     182 
     183    priv = libvlc_priv (p_libvlc); 
     184    priv->p_playlist = NULL; 
     185    priv->p_interaction = NULL; 
     186    priv->p_vlm = NULL; 
     187    p_libvlc->psz_object_name = strdup( "libvlc" ); 
     188 
     189    /* Initialize message queue */ 
     190    msg_Create( p_libvlc ); 
     191 
     192    /* Find verbosity from VLC_VERBOSE environment variable */ 
     193    psz_env = getenv( "VLC_VERBOSE" ); 
     194    if( psz_env != NULL ) 
     195        priv->i_verbose = atoi( psz_env ); 
     196    else 
     197        priv->i_verbose = 3; 
     198#if defined( HAVE_ISATTY ) && !defined( WIN32 ) 
     199    priv->b_color = isatty( 2 ); /* 2 is for stderr */ 
     200#else 
     201    priv->b_color = false; 
     202#endif 
     203 
     204    /* Announce who we are - Do it only for first instance ? */ 
     205    msg_Dbg( p_libvlc, COPYRIGHT_MESSAGE ); 
     206    msg_Dbg( p_libvlc, "libvlc was configured with %s", CONFIGURE_LINE ); 
     207 
     208    /* Initialize mutexes */ 
     209    vlc_mutex_init( &priv->timer_lock ); 
     210    vlc_mutex_init( &priv->config_lock ); 
     211 
     212    /* Store data for the non-reentrant API */ 
     213    p_static_vlc = p_libvlc; 
     214 
     215    return p_libvlc; 
     216
     217 
     218/** 
     219 * Initialize a libvlc instance 
     220 * This function initializes a previously allocated libvlc instance: 
     221 *  - CPU detection 
     222 *  - gettext initialization 
     223 *  - message queue, module bank and playlist initialization 
     224 *  - configuration and commandline parsing 
     225 */ 
     226int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc, 
     227                         const char *ppsz_argv[] ) 
     228
     229    libvlc_global_data_t *p_libvlc_global = vlc_global(); 
     230    libvlc_priv_t *priv = libvlc_priv (p_libvlc); 
     231    char         p_capabilities[200]; 
     232    char *       p_tmp = NULL; 
     233    char *       psz_modules = NULL; 
     234    char *       psz_parser = NULL; 
     235    char *       psz_control = NULL; 
     236    bool   b_exit = false; 
     237    int          i_ret = VLC_EEXIT; 
     238    playlist_t  *p_playlist = NULL; 
     239    vlc_value_t  val; 
     240#if defined( ENABLE_NLS ) \ 
     241     && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) 
     242# if defined (WIN32) || defined (__APPLE__) 
     243    char *       psz_language; 
     244#endif 
     245#endif 
     246 
     247    /* System specific initialization code */ 
     248    system_Init( p_libvlc, &i_argc, ppsz_argv ); 
     249 
     250    /* Get the executable name (similar to the basename command) */ 
     251    if( i_argc > 0 && ppsz_argv[0][0] ) 
     252    { 
     253        free( p_libvlc->psz_object_name ); 
     254 
     255        const char *psz_exe = strrchr( ppsz_argv[0], '/' ); 
     256        if( psz_exe && *(psz_exe + 1) ) 
     257            p_libvlc->psz_object_name = strdup( psz_exe + 1 ); 
     258        else 
     259            p_libvlc->psz_object_name = strdup( ppsz_argv[0] ); 
     260    } 
     261 
     262    /* 
     263     * Support for gettext 
     264     */ 
     265    LoadMessages (); 
     266 
     267    /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */ 
     268    msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") ); 
     269 
     270    /* Initialize the module bank and load the configuration of the 
     271     * main module. We need to do this at this stage to be able to display 
     272     * a short help if required by the user. (short help == main module 
     273     * options) */ 
     274    module_InitBank( p_libvlc ); 
     275 
     276    if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true ) ) 
     277    { 
     278        module_EndBank( p_libvlc ); 
    110279        return VLC_EGENERIC; 
    111  
    112     i_ret = var_Set( p_libvlc, psz_var, value ); 
    113  
    114     LIBVLC_FUNC_END; 
    115     return i_ret; 
     280    } 
     281 
     282#ifdef __APPLE__ 
     283    /* vlc_thread_set_priority needs to query the config, 
     284     * so this is the earliest moment where we can set this */ 
     285    vlc_thread_set_priority( p_libvlc, VLC_THREAD_PRIORITY_LOW ); 
     286#endif 
     287 
     288    /* Check for short help option */ 
     289    if( config_GetInt( p_libvlc, "help" ) > 0 ) 
     290    { 
     291        Help( p_libvlc, "help" ); 
     292        b_exit = true; 
     293        i_ret = VLC_EEXITSUCCESS; 
     294    } 
     295    /* Check for version option */ 
     296    else if( config_GetInt( p_libvlc, "version" ) > 0 ) 
     297    { 
     298        Version(); 
     299        b_exit = true; 
     300        i_ret = VLC_EEXITSUCCESS; 
     301    } 
     302 
     303    /* Set the config file stuff */ 
     304    priv->psz_configfile = config_GetCustomConfigFile( p_libvlc ); 
     305 
     306    /* Check for plugins cache options */ 
     307    if( config_GetInt( p_libvlc, "reset-plugins-cache" ) > 0 ) 
     308    { 
     309        p_libvlc_global->p_module_bank->b_cache_delete = true; 
     310    } 
     311 
     312    /* Will be re-done properly later on */ 
     313    priv->i_verbose = config_GetInt( p_libvlc, "verbose" ); 
     314 
     315    /* Check for daemon mode */ 
     316#ifndef WIN32 
     317    if( config_GetInt( p_libvlc, "daemon" ) > 0 ) 
     318    { 
     319#ifdef HAVE_DAEMON 
     320        char *psz_pidfile = NULL; 
     321 
     322        if( daemon( 1, 0) != 0 ) 
     323        { 
     324            msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" ); 
     325            b_exit = true; 
     326        } 
     327        b_daemon = true; 
     328 
     329        /* lets check if we need to write the pidfile */ 
     330        psz_pidfile = config_GetPsz( p_libvlc, "pidfile" ); 
     331        if( psz_pidfile != NULL ) 
     332        { 
     333            FILE *pidfile; 
     334            pid_t i_pid = getpid (); 
     335            msg_Dbg( p_libvlc, "PID is %d, writing it to %s", 
     336                               i_pid, psz_pidfile ); 
     337            pidfile = utf8_fopen( psz_pidfile,"w" ); 
     338            if( pidfile != NULL ) 
     339            { 
     340                utf8_fprintf( pidfile, "%d", (int)i_pid ); 
     341                fclose( pidfile ); 
     342            } 
     343            else 
     344            { 
     345                msg_Err( p_libvlc, "cannot open pid file for writing: %s (%m)", 
     346                         psz_pidfile ); 
     347            } 
     348        } 
     349        free( psz_pidfile ); 
     350 
     351#else 
     352        pid_t i_pid; 
     353 
     354        if( ( i_pid = fork() ) < 0 ) 
     355        { 
     356            msg_Err( p_libvlc, "unable to fork vlc to daemon mode" ); 
     357            b_exit = true; 
     358        } 
     359        else if( i_pid ) 
     360        { 
     361            /* This is the parent, exit right now */ 
     362            msg_Dbg( p_libvlc, "closing parent process" ); 
     363            b_exit = true; 
     364            i_ret = VLC_EEXITSUCCESS; 
     365        } 
     366        else 
     367        { 
     368            /* We are the child */ 
     369            msg_Dbg( p_libvlc, "daemon spawned" ); 
     370            close( STDIN_FILENO ); 
     371            close( STDOUT_FILENO ); 
     372            close( STDERR_FILENO ); 
     373 
     374            b_daemon = true; 
     375        } 
     376#endif 
     377    } 
     378#endif 
     379 
     380    if( b_exit ) 
     381    { 
     382        module_EndBank( p_libvlc ); 
     383        return i_ret; 
     384    } 
     385 
     386    /* Check for translation config option */ 
     387#if defined( ENABLE_NLS ) \ 
     388     && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) 
     389# if defined (WIN32) || defined (__APPLE__) 
     390    /* This ain't really nice to have to reload the config here but it seems 
     391     * the only way to do it. */ 
     392 
     393    if( !config_GetInt( p_libvlc, "ignore-config" ) ) 
     394        config_LoadConfigFile( p_libvlc, "main" ); 
     395    config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true ); 
     396 
     397    /* Check if the user specified a custom language */ 
     398    psz_language = config_GetPsz( p_libvlc, "language" ); 
     399    if( psz_language && *psz_language && strcmp( psz_language, "auto" ) ) 
     400    { 
     401        bool b_cache_delete = p_libvlc_global->p_module_bank->b_cache_delete; 
     402 
     403        /* Reset the default domain */ 
     404        SetLanguage( psz_language ); 
     405 
     406        /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */ 
     407        msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") ); 
     408 
     409        module_EndBank( p_libvlc ); 
     410        module_InitBank( p_libvlc ); 
     411        if( !config_GetInt( p_libvlc, "ignore-config" ) ) 
     412            config_LoadConfigFile( p_libvlc, "main" ); 
     413        config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true ); 
     414        p_libvlc_global->p_module_bank->b_cache_delete = b_cache_delete; 
     415    } 
     416    free( psz_language ); 
     417# endif 
     418#endif 
     419 
     420    /* 
     421     * Load the builtins and plugins into the module_bank. 
     422     * We have to do it before config_Load*() because this also gets the 
     423     * list of configuration options exported by each module and loads their 
     424     * default values. 
     425     */ 
     426    module_LoadBuiltins( p_libvlc ); 
     427    module_LoadPlugins( p_libvlc ); 
     428    if( p_libvlc->b_die ) 
     429    { 
     430        b_exit = true; 
     431    } 
     432 
     433    msg_Dbg( p_libvlc, "module bank initialized, found %i modules", 
     434             vlc_internals( p_libvlc_global->p_module_bank )->i_children ); 
     435 
     436    /* Check for help on modules */ 
     437    if( (p_tmp = config_GetPsz( p_libvlc, "module" )) ) 
     438    { 
     439        Help( p_libvlc, p_tmp ); 
     440        free( p_tmp ); 
     441        b_exit = true; 
     442        i_ret = VLC_EEXITSUCCESS; 
     443    } 
     444    /* Check for long help option */ 
     445    else if( config_GetInt( p_libvlc, "longhelp" ) > 0 ) 
     446    { 
     447        Help( p_libvlc, "longhelp" ); 
     448        b_exit = true; 
     449        i_ret = VLC_EEXITSUCCESS; 
     450    } 
     451    /* Check for module list option */ 
     452    else if( config_GetInt( p_libvlc, "list" ) > 0 ) 
     453    { 
     454        ListModules( p_libvlc, false ); 
     455        b_exit = true; 
     456        i_ret = VLC_EEXITSUCCESS; 
     457    } 
     458    else if( config_GetInt( p_libvlc, "list-verbose" ) > 0 ) 
     459    { 
     460        ListModules( p_libvlc, true ); 
     461        b_exit = true; 
     462        i_ret = VLC_EEXITSUCCESS; 
     463    } 
     464 
     465    /* Check for config file options */ 
     466    if( !config_GetInt( p_libvlc, "ignore-config" ) ) 
     467    { 
     468        if( config_GetInt( p_libvlc, "reset-config" ) > 0 ) 
     469        { 
     470            config_ResetAll( p_libvlc ); 
     471            config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true ); 
     472            config_SaveConfigFile( p_libvlc, NULL ); 
     473        } 
     474        if( config_GetInt( p_libvlc, "save-config" ) > 0 ) 
     475        { 
     476            config_LoadConfigFile( p_libvlc, NULL ); 
     477            config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, true ); 
     478            config_SaveConfigFile( p_libvlc, NULL ); 
     479        } 
     480    } 
     481 
     482    if( b_exit ) 
     483    { 
     484        module_EndBank( p_libvlc ); 
     485        return i_ret; 
     486    } 
     487 
     488    /* 
     489     * Init device values 
     490     */ 
     491    InitDeviceValues( p_libvlc ); 
     492 
     493    /* 
     494     * Override default configuration with config file settings 
     495     */ 
     496    if( !config_GetInt( p_libvlc, "ignore-config" ) ) 
     497        config_LoadConfigFile( p_libvlc, NULL ); 
     498 
     499    /* 
     500     * Override configuration with command line settings 
     501     */ 
     502    if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, false ) ) 
     503    { 
     504#ifdef WIN32 
     505        ShowConsole( false ); 
     506        /* Pause the console because it's destroyed when we exit */ 
     507        fprintf( stderr, "The command line options couldn't be loaded, check " 
     508                 "that they are valid.\n" ); 
     509        PauseConsole(); 
     510#endif 
     511        module_EndBank( p_libvlc ); 
     512        return VLC_EGENERIC; 
     513    } 
     514 
     515    /* 
     516     * System specific configuration 
     517     */ 
     518    system_Configure( p_libvlc, &i_argc, ppsz_argv ); 
     519 
     520/* FIXME: could be replaced by using Unix sockets */ 
     521#ifdef HAVE_DBUS_3 
     522    dbus_threads_init_default(); 
     523 
     524    if( config_GetInt( p_libvlc, "one-instance" ) > 0 ) 
     525    { 
     526        /* Initialise D-Bus interface, check for other instances */ 
     527        DBusConnection  *p_conn = NULL; 
     528        DBusError       dbus_error; 
     529 
     530        dbus_error_init( &dbus_error ); 
     531 
     532        /* connect to the session bus */ 
     533        p_conn = dbus_bus_get( DBUS_BUS_SESSION, &dbus_error ); 
     534        if( !p_conn ) 
     535        { 
     536            msg_Err( p_libvlc, "Failed to connect to D-Bus session daemon: %s", 
     537                    dbus_error.message ); 
     538            dbus_error_free( &dbus_error ); 
     539        } 
     540        else 
     541        { 
     542            /* check if VLC is available on the bus 
     543             * if not: D-Bus control is not enabled on the other 
     544             * instance and we can't pass MRLs to it */ 
     545            DBusMessage *p_test_msg = NULL; 
     546            DBusMessage *p_test_reply = NULL; 
     547            p_test_msg =  dbus_message_new_method_call( 
     548                    "org.mpris.vlc", "/", 
     549                    "org.freedesktop.MediaPlayer", "Identity" ); 
     550            /* block until a reply arrives */ 
     551            p_test_reply = dbus_connection_send_with_reply_and_block( 
     552                    p_conn, p_test_msg, -1, &dbus_error ); 
     553            dbus_message_unref( p_test_msg ); 
     554            if( p_test_reply == NULL ) 
     555            { 
     556                dbus_error_free( &dbus_error ); 
     557                msg_Dbg( p_libvlc, "No Media Player is running. " 
     558                        "Continuing normally." ); 
     559            } 
     560            else 
     561            { 
     562                int i_input; 
     563                DBusMessage* p_dbus_msg = NULL; 
     564                DBusMessageIter dbus_args; 
     565                DBusPendingCall* p_dbus_pending = NULL; 
     566                dbus_bool_t b_play; 
     567 
     568                dbus_message_unref( p_test_reply ); 
     569                msg_Warn( p_libvlc, "Another Media Player is running. Exiting"); 
     570 
     571                for( i_input = optind;i_input < i_argc;i_input++ ) 
     572                { 
     573                    msg_Dbg( p_libvlc, "Adds %s to the running Media Player", 
     574                            ppsz_argv[i_input] ); 
     575 
     576                    p_dbus_msg = dbus_message_new_method_call( 
     577                            "org.mpris.vlc", "/TrackList", 
     578                            "org.freedesktop.MediaPlayer", "AddTrack" ); 
     579 
     580                    if ( NULL == p_dbus_msg ) 
     581                    { 
     582                        msg_Err( p_libvlc, "D-Bus problem" ); 
     583                        system_End( p_libvlc ); 
     584                        exit( VLC_ETIMEOUT ); 
     585                    } 
     586 
     587                    /* append MRLs */ 
     588                    dbus_message_iter_init_append( p_dbus_msg, &dbus_args ); 
     589                    if ( !dbus_message_iter_append_basic( &dbus_args, 
     590                                DBUS_TYPE_STRING, &ppsz_argv[i_input] ) ) 
     591                    { 
     592                        msg_Err( p_libvlc, "Out of memory" ); 
     593                        dbus_message_unref( p_dbus_msg ); 
     594                        system_End( p_libvlc ); 
     595                        exit( VLC_ENOMEM ); 
     596                    } 
     597                    b_play = TRUE; 
     598                    if( config_GetInt( p_libvlc, "playlist-enqueue" ) > 0 ) 
     599                        b_play = FALSE; 
     600                    if ( !dbus_message_iter_append_basic( &dbus_args, 
     601                                DBUS_TYPE_BOOLEAN, &b_play ) ) 
     602                    { 
     603                        msg_Err( p_libvlc, "Out of memory" ); 
     604                        dbus_message_unref( p_dbus_msg ); 
     605                        system_End( p_libvlc ); 
     606                        exit( VLC_ENOMEM ); 
     607                    } 
     608 
     609                    /* send message and get a handle for a reply */ 
     610                    if ( !dbus_connection_send_with_reply ( p_conn, 
     611                                p_dbus_msg, &p_dbus_pending, -1 ) ) 
     612                    { 
     613                        msg_Err( p_libvlc, "D-Bus problem" ); 
     614                        dbus_message_unref( p_dbus_msg ); 
     615                        system_End( p_libvlc ); 
     616                        exit( VLC_ETIMEOUT ); 
     617                    } 
     618 
     619                    if ( NULL == p_dbus_pending ) 
     620                    { 
     621                        msg_Err( p_libvlc, "D-Bus problem" ); 
     622                        dbus_message_unref( p_dbus_msg ); 
     623                        system_End( p_libvlc ); 
     624                        exit( VLC_ETIMEOUT ); 
     625                    } 
     626                    dbus_connection_flush( p_conn ); 
     627                    dbus_message_unref( p_dbus_msg ); 
     628                    /* block until we receive a reply */ 
     629                    dbus_pending_call_block( p_dbus_pending ); 
     630                    dbus_pending_call_unref( p_dbus_pending ); 
     631                } /* processes all command line MRLs */ 
     632 
     633                /* bye bye */ 
     634                system_End( p_libvlc ); 
     635                exit( VLC_SUCCESS ); 
     636            } 
     637        } 
     638        /* we unreference the connection when we've finished with it */ 
     639        if( p_conn ) dbus_connection_unref( p_conn ); 
     640    } 
     641#endif 
     642 
     643    /* 
     644     * Message queue options 
     645     */ 
     646 
     647    var_Create( p_libvlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); 
     648    if( config_GetInt( p_libvlc, "quiet" ) > 0 ) 
     649    { 
     650        val.i_int = -1; 
     651        var_Set( p_libvlc, "verbose", val ); 
     652    } 
     653    var_AddCallback( p_libvlc, "verbose", VerboseCallback, NULL ); 
     654    var_Change( p_libvlc, "verbose", VLC_VAR_TRIGGER_CALLBACKS, NULL, NULL ); 
     655 
     656    if( priv->b_color ) 
     657        priv->b_color = config_GetInt( p_libvlc, "color" ) > 0; 
     658 
     659    /* 
     660     * Output messages that may still be in the queue 
     661     */ 
     662    msg_Flush( p_libvlc ); 
     663 
     664    if( !config_GetInt( p_libvlc, "fpu" ) ) 
     665        cpu_flags &= ~CPU_CAPABILITY_FPU; 
     666 
     667#if defined( __i386__ ) || defined( __x86_64__ ) 
     668    if( !config_GetInt( p_libvlc, "mmx" ) ) 
     669        cpu_flags &= ~CPU_CAPABILITY_MMX; 
     670    if( !config_GetInt( p_libvlc, "3dn" ) ) 
     671        cpu_flags &= ~CPU_CAPABILITY_3DNOW; 
     672    if( !config_GetInt( p_libvlc, "mmxext" ) ) 
     673        cpu_flags &= ~CPU_CAPABILITY_MMXEXT; 
     674    if( !config_GetInt( p_libvlc, "sse" ) ) 
     675        cpu_flags &= ~CPU_CAPABILITY_SSE; 
     676    if( !config_GetInt( p_libvlc, "sse2" ) ) 
     677        cpu_flags &= ~CPU_CAPABILITY_SSE2; 
     678#endif 
     679#if defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ ) 
     680    if( !config_GetInt( p_libvlc, "altivec" ) ) 
     681        cpu_flags &= ~CPU_CAPABILITY_ALTIVEC; 
     682#endif 
     683 
     684#define PRINT_CAPABILITY( capability, string )                              \ 
     685    if( vlc_CPU() & capability )                                            \ 
     686    {                                                                       \ 
     687        strncat( p_capabilities, string " ",                                \ 
     688                 sizeof(p_capabilities) - strlen(p_capabilities) );         \ 
     689        p_capabilities[sizeof(p_capabilities) - 1] = '\0';                  \ 
     690    } 
     691 
     692    p_capabilities[0] = '\0'; 
     693    PRINT_CAPABILITY( CPU_CAPABILITY_486, "486" ); 
     694    PRINT_CAPABILITY( CPU_CAPABILITY_586, "586" ); 
     695    PRINT_CAPABILITY( CPU_CAPABILITY_PPRO, "Pentium Pro" ); 
     696    PRINT_CAPABILITY( CPU_CAPABILITY_MMX, "MMX" ); 
     697    PRINT_CAPABILITY( CPU_CAPABILITY_3DNOW, "3DNow!" ); 
     698    PRINT_CAPABILITY( CPU_CAPABILITY_MMXEXT, "MMXEXT" ); 
     699    PRINT_CAPABILITY( CPU_CAPABILITY_SSE, "SSE" ); 
     700    PRINT_CAPABILITY( CPU_CAPABILITY_SSE2, "SSE2" ); 
     701    PRINT_CAPABILITY( CPU_CAPABILITY_ALTIVEC, "AltiVec" ); 
     702    PRINT_CAPABILITY( CPU_CAPABILITY_FPU, "FPU" ); 
     703    msg_Dbg( p_libvlc, "CPU has capabilities %s", p_capabilities ); 
     704 
     705    /* 
     706     * Choose the best memcpy module 
     707     */ 
     708    priv->p_memcpy_module = module_Need( p_libvlc, "memcpy", "$memcpy", 0 ); 
     709 
     710    priv->b_stats = config_GetInt( p_libvlc, "stats" ) > 0; 
     711    priv->i_timers = 0; 
     712    priv->pp_timers = NULL; 
     713 
     714    /* Init stats */ 
     715    p_libvlc->p_stats = (global_stats_t *)malloc( sizeof( global_stats_t ) ); 
     716    if( !p_libvlc->p_stats ) 
     717    { 
     718        vlc_object_release( p_libvlc ); 
     719        return VLC_ENOMEM; 
     720    } 
     721    vlc_mutex_init( &p_libvlc->p_stats->lock ); 
     722    priv->p_stats_computer = NULL; 
     723 
     724    /* Init the array that holds every input item */ 
     725    ARRAY_INIT( priv->input_items ); 
     726    priv->i_last_input_id = 0; 
     727 
     728    /* 
     729     * Initialize hotkey handling 
     730     */ 
     731    var_Create( p_libvlc, "key-pressed", VLC_VAR_INTEGER ); 
     732    var_Create( p_libvlc, "key-action", VLC_VAR_INTEGER ); 
     733    p_libvlc->p_hotkeys = malloc( libvlc_hotkeys_size ); 
     734    /* Do a copy (we don't need to modify the strings) */ 
     735    memcpy( p_libvlc->p_hotkeys, libvlc_hotkeys, libvlc_hotkeys_size ); 
     736    var_AddCallback( p_libvlc, "key-pressed", vlc_key_to_action, 
     737                     p_libvlc->p_hotkeys ); 
     738 
     739    /* Initialize interaction */ 
     740    priv->p_interaction = interaction_Init( p_libvlc ); 
     741 
     742    /* Initialize playlist and get commandline files */ 
     743    playlist_ThreadCreate( p_libvlc ); 
     744    if( !priv->p_playlist ) 
     745    { 
     746        msg_Err( p_libvlc, "playlist initialization failed" ); 
     747        if( priv->p_memcpy_module != NULL ) 
     748        { 
     749            module_Unneed( p_libvlc, priv->p_memcpy_module ); 
     750        } 
     751        module_EndBank( p_libvlc ); 
     752        return VLC_EGENERIC; 
     753    } 
     754    p_playlist = priv->p_playlist; 
     755 
     756    psz_modules = config_GetPsz( p_playlist, "services-discovery" ); 
     757    if( psz_modules && *psz_modules ) 
     758    { 
     759        /* Add service discovery modules */ 
     760        playlist_ServicesDiscoveryAdd( p_playlist, psz_modules ); 
     761    } 
     762    free( psz_modules ); 
     763 
     764#ifdef ENABLE_SOUT 
     765    /* Initialize VLM if vlm-conf is specified */ 
     766    psz_parser = config_GetPsz( p_libvlc, "vlm-conf" ); 
     767    if( psz_parser && *psz_parser ) 
     768    { 
     769        priv->p_vlm = vlm_New( p_libvlc ); 
     770        if( !priv->p_vlm ) 
     771            msg_Err( p_libvlc, "VLM initialization failed" ); 
     772    } 
     773    free( psz_parser ); 
     774#endif 
     775 
     776    /* 
     777     * Load background interfaces 
     778     */ 
     779    psz_modules = config_GetPsz( p_libvlc, "extraintf" ); 
     780    psz_control = config_GetPsz( p_libvlc, "control" ); 
     781 
     782    if( psz_modules && *psz_modules && psz_control && *psz_control ) 
     783    { 
     784        psz_modules = (char *)realloc( psz_modules, strlen( psz_modules ) + 
     785                                                    strlen( psz_control ) + 1 ); 
     786        sprintf( psz_modules, "%s:%s", psz_modules, psz_control ); 
     787    } 
     788    else if( psz_control && *psz_control ) 
     789    { 
     790        free( psz_modules ); 
     791        psz_modules = strdup( psz_control ); 
     792    } 
     793 
     794    psz_parser = psz_modules; 
     795    while ( psz_parser && *psz_parser ) 
     796    { 
     797        char *psz_module, *psz_temp; 
     798        psz_module = psz_parser; 
     799        psz_parser = strchr( psz_module, ':' ); 
     800        if ( psz_parser ) 
     801        { 
     802            *psz_parser = '\0'; 
     803            psz_parser++; 
     804        } 
     805        psz_temp = (char *)malloc( strlen(psz_module) + sizeof(",none") ); 
     806        if( psz_temp ) 
     807        { 
     808            sprintf( psz_temp, "%s,none", psz_module ); 
     809            libvlc_InternalAddIntf( p_libvlc, psz_temp, false ); 
     810            free( psz_temp ); 
     811        } 
     812    } 
     813    free( psz_modules ); 
     814    free( psz_control ); 
     815 
     816    /* 
     817     * Always load the hotkeys interface if it exists 
     818     */ 
     819    libvlc_InternalAddIntf( p_libvlc, "hotkeys,none", false ); 
     820 
     821#ifdef HAVE_DBUS_3 
     822    /* loads dbus control interface if in one-instance mode 
     823     * we do it only when playlist exists, because dbus module needs it */ 
     824    if( config_GetInt( p_libvlc, "one-instance" ) > 0 ) 
     825        libvlc_InternalAddIntf( p_libvlc, "dbus,none", false ); 
     826 
     827    /* Prevents the power management daemon from suspending the system 
     828     * when VLC is active */ 
     829    if( config_GetInt( p_libvlc, "inhibit" ) > 0 ) 
     830        libvlc_InternalAddIntf( p_libvlc, "inhibit,none", false ); 
     831#endif 
     832 
     833    /* 
     834     * If needed, load the Xscreensaver interface 
     835     * Currently, only for X 
     836     */ 
     837#ifdef HAVE_X11_XLIB_H 
     838    if( config_GetInt( p_libvlc, "disable-screensaver" ) ) 
     839    { 
     840        libvlc_InternalAddIntf( p_libvlc, "screensaver,none", false ); 
     841    } 
     842#endif 
     843 
     844    if( config_GetInt( p_libvlc, "file-logging" ) > 0 ) 
     845    { 
     846        libvlc_InternalAddIntf( p_libvlc, "logger,none", false ); 
     847    } 
     848#ifdef HAVE_SYSLOG_H 
     849    if( config_GetInt( p_libvlc, "syslog" ) > 0 ) 
     850    { 
     851        char *logmode = var_CreateGetString( p_libvlc, "logmode" ); 
     852        var_SetString( p_libvlc, "logmode", "syslog" ); 
     853        libvlc_InternalAddIntf( p_libvlc, "logger,none", false ); 
     854 
     855        if( logmode ) 
     856        { 
     857            var_SetString( p_libvlc, "logmode", logmode ); 
     858            free( logmode ); 
     859        } 
     860        else 
     861            var_Destroy( p_libvlc, "logmode" ); 
     862    } 
     863#endif 
     864 
     865    if( config_GetInt( p_libvlc, "show-intf" ) > 0 ) 
     866    { 
     867        libvlc_InternalAddIntf( p_libvlc, "showintf,none", false ); 
     868    } 
     869 
     870    if( config_GetInt( p_libvlc, "network-synchronisation") > 0 ) 
     871    { 
     872        libvlc_InternalAddIntf( p_libvlc, "netsync,none", false ); 
     873    } 
     874 
     875#ifdef WIN32 
     876    if( config_GetInt( p_libvlc, "prefer-system-codecs") > 0 ) 
     877    { 
     878        char *psz_codecs = config_GetPsz( p_playlist, "codec" ); 
     879        if( psz_codecs ) 
     880        { 
     881            char *psz_morecodecs; 
     882            asprintf(&psz_morecodecs, "%s,dmo,quicktime", psz_codecs); 
     883            if( psz_morecodecs ) 
     884            { 
     885                config_PutPsz( p_libvlc, "codec", psz_morecodecs); 
     886                free( psz_morecodecs ); 
     887            } 
     888        } 
     889        else 
     890            config_PutPsz( p_libvlc, "codec", "dmo,quicktime"); 
     891        free( psz_codecs ); 
     892    } 
     893#endif 
     894 
     895    /* 
     896     * FIXME: kludge to use a p_libvlc-local variable for the Mozilla plugin 
     897     */ 
     898    var_Create( p_libvlc, "drawable", VLC_VAR_INTEGER ); 
     899    var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER ); 
     900    var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER ); 
     901    var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER ); 
     902    var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER ); 
     903    var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER ); 
     904    var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER ); 
     905    var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER ); 
     906    var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER ); 
     907 
     908    /* Create volume callback system. */ 
     909    var_Create( p_libvlc, "volume-change", VLC_VAR_BOOL ); 
     910 
     911    /* 
     912     * Get input filenames given as commandline arguments 
     913     */ 
     914    GetFilenames( p_libvlc, i_argc, ppsz_argv ); 
     915 
     916    /* 
     917     * Get --open argument 
     918     */ 
     919    var_Create( p_libvlc, "open", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); 
     920    var_Get( p_libvlc, "open", &val ); 
     921    if ( val.psz_string != NULL && *val.psz_string ) 
     922    { 
     923        playlist_t *p_playlist = pl_Yield( p_libvlc ); 
     924        playlist_AddExt( p_playlist, val.psz_string, NULL, PLAYLIST_INSERT, 0, 
     925                         -1, NULL, 0, true, false ); 
     926        pl_Release( p_libvlc ); 
     927    } 
     928    free( val.psz_string ); 
     929 
     930    return VLC_SUCCESS; 
    116931} 
    117932 
    118 /***************************************************************************** 
    119  * VLC_VariableGet: get a vlc variable 
    120  *****************************************************************************/ 
    121 int VLC_VariableGet( int i_object, char const *psz_var, vlc_value_t *p_value ) 
     933/** 
     934 * Cleanup a libvlc instance. The instance is not completely deallocated 
     935 * \param p_libvlc the instance to clean 
     936 */ 
     937int libvlc_InternalCleanup( libvlc_int_t *p_libvlc ) 
    122938{ 
    123     int i_ret; 
    124     LIBVLC_FUNC; 
    125     i_ret = var_Get( p_libvlc , psz_var, p_value ); 
    126     LIBVLC_FUNC_END; 
    127     return i_ret; 
     939    intf_thread_t      * p_intf = NULL; 
     940    vout_thread_t      * p_vout = NULL; 
     941    libvlc_priv_t      *priv = libvlc_priv (p_libvlc); 
     942 
     943    /* Ask the interfaces to stop and destroy them */ 
     944    msg_Dbg( p_libvlc, "removing all interfaces" ); 
     945    while( (p_intf = vlc_object_find( p_libvlc, VLC_OBJECT_INTF, FIND_CHILD )) ) 
     946    { 
     947        intf_StopThread( p_intf ); 
     948        vlc_object_detach( p_intf ); 
     949        vlc_object_release( p_intf ); /* for intf_Create() */ 
     950        vlc_object_release( p_intf ); /* for vlc_object_find() */ 
     951    } 
     952 
     953    /* Free video outputs */ 
     954    msg_Dbg( p_libvlc, "removing all video outputs" ); 
     955    while( (p_vout = vlc_object_find( p_libvlc, VLC_OBJECT_VOUT, FIND_CHILD )) ) 
     956    { 
     957        vlc_object_detach( p_vout ); 
     958        vlc_object_release( p_vout ); 
     959        vout_Destroy( p_vout ); 
     960    } 
     961 
     962#ifdef ENABLE_SOUT 
     963    playlist_t         * p_playlist; 
     964    sout_instance_t    * p_sout; 
     965 
     966    p_playlist = vlc_object_find( p_libvlc, VLC_OBJECT_PLAYLIST, FIND_CHILD ); 
     967    if( p_playlist ) 
     968    { 
     969        p_sout = vlc_object_find( p_playlist, VLC_OBJECT_SOUT, FIND_CHILD ); 
     970        if( p_sout ) 
     971        { 
     972            msg_Dbg( p_sout, "removing kept stream output" ); 
     973            vlc_object_detach( (vlc_object_t*)p_sout ); 
     974            vlc_object_release( (vlc_object_t*)p_sout ); 
     975            sout_DeleteInstance( p_sout ); 
     976        } 
     977 
     978        vlc_object_release( p_playlist ); 
     979    } 
     980 
     981    /* Destroy VLM if created in libvlc_InternalInit */ 
     982    if( priv->p_vlm ) 
     983    { 
     984        vlm_Delete( priv->p_vlm ); 
     985    } 
     986