Changeset e9947bec0ae6a8f81dcc10e2595dd6cebd72641f

Show
Ignore:
Timestamp:
09/15/06 21:48:42 (2 years ago)
Author:
Clément Stenac <zorglub@videolan.org>
git-committer:
Clément Stenac <zorglub@videolan.org> 1158349722 +0000
git-parent:

[fcfc11bd0f6ada52543bf1f213d4f0d86de59b8e]

git-author:
Clément Stenac <zorglub@videolan.org> 1158349722 +0000
Message:

Split libvlc.c:
* instances creation/deletion stuff to libvlc-common.c
* implementation of the old libvlc API to libvlc.c

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • include/libvlc_internal.h

    rf485214 re9947be  
    3232#include <vlc/vlc.h> 
    3333 
     34/*************************************************************************** 
     35 * Internal creation and destruction functions 
     36 ***************************************************************************/ 
     37libvlc_int_t *libvlc_InternalCreate(); 
     38int libvlc_InternalInit( libvlc_int_t *, int, char *ppsz_argv[] ); 
     39int libvlc_InternalCleanup( libvlc_int_t * ); 
     40int libvlc_InternalDestroy( libvlc_int_t *, vlc_bool_t ); 
     41 
     42int libvlc_InternalAddIntf( libvlc_int_t *, char const *, vlc_bool_t, 
     43                            vlc_bool_t, int, char ** ); 
     44 
     45/*************************************************************************** 
     46 * Opaque structures for libvlc API 
     47 ***************************************************************************/ 
     48 
    3449struct libvlc_instance_t 
    3550{ 

  • src/Makefile.am

    r47eb220 re9947be  
    253253SOURCES_libvlc_common = \ 
    254254    libvlc.c \ 
     255    libvlc-common.c \ 
    255256    libvlc.h \ 
    256257    interface/interface.c \ 

  • src/libvlc.c

    r28d49d9 re9947be  
    3939#include <vlc/input.h> 
    4040 
    41 #include <errno.h>                                                 /* ENOMEM */ 
    42 #include <stdio.h>                                              /* sprintf() */ 
    43 #include <string.h>                                            /* strerror() */ 
    44 #include <stdlib.h>                                                /* free() */ 
    45  
    46 #ifndef WIN32 
    47 #   include <netinet/in.h>                            /* BSD: struct in_addr */ 
    48 #endif 
    49  
    50 #ifdef HAVE_UNISTD_H 
    51 #   include <unistd.h> 
    52 #elif defined( WIN32 ) && !defined( UNDER_CE ) 
    53 #   include <io.h> 
    54 #endif 
    55  
    56 #ifdef WIN32                       /* optind, getopt(), included in unistd.h */ 
    57 #   include "extras/getopt.h" 
    58 #endif 
    59  
    60 #ifdef HAVE_LOCALE_H 
    61 #   include <locale.h> 
    62 #endif 
    63  
    64 #ifdef HAVE_HAL 
    65 #   include <hal/libhal.h> 
    66 #endif 
    67  
    68 #include "vlc_cpu.h"                                        /* CPU detection */ 
    69 #include "os_specific.h" 
    70  
    71 #include "vlc_error.h" 
    72  
    73 #include "vlc_playlist.h" 
    74 #include "vlc_interface.h" 
     41#include <libvlc_internal.h> 
     42 
     43#include <vlc_error.h> 
    7544 
    7645#include "audio_output.h" 
    77  
    7846#include "vlc_video.h" 
    7947#include "video_output.h" 
    80  
    81 #include "stream_output.h" 
    82 #include "charset.h" 
    83  
    84 #include "libvlc.h" 
    85  
    86 /***************************************************************************** 
    87  * The evil global variable. We handle it with care, don't worry. 
    88  *****************************************************************************/ 
    89 static libvlc_global_data_t   libvlc_global; 
    90 static libvlc_global_data_t * p_libvlc_global; 
    91 static libvlc_int_t *    p_static_vlc; 
    92  
    93 /***************************************************************************** 
    94  * Local prototypes 
    95  *****************************************************************************/ 
    96 static int AddIntfInternal( int i_object, char const *psz_module, 
    97                              vlc_bool_t b_block, vlc_bool_t b_play, 
    98                              int i_options, char **ppsz_options ); 
    99  
    100 void LocaleInit( vlc_object_t * ); 
    101 void LocaleDeinit( void ); 
    102 static void SetLanguage   ( char const * ); 
    103 static int  GetFilenames  ( libvlc_int_t *, int, char *[] ); 
    104 static void Help          ( libvlc_int_t *, char const *psz_help_name ); 
    105 static void Usage         ( libvlc_int_t *, char const *psz_module_name ); 
    106 static void ListModules   ( libvlc_int_t * ); 
    107 static void Version       ( void ); 
    108  
    109 #ifdef WIN32 
    110 static void ShowConsole   ( vlc_bool_t ); 
    111 static void PauseConsole  ( void ); 
    112 #endif 
    113 static int  ConsoleWidth  ( void ); 
    114  
    115 static int  VerboseCallback( vlc_object_t *, char const *, 
    116                              vlc_value_t, vlc_value_t, void * ); 
    117  
    118 static void InitDeviceValues( libvlc_int_t * ); 
    119  
    120 /***************************************************************************** 
    121  * vlc_current_object: return the current object. 
    122  ***************************************************************************** 
    123  * If i_object is non-zero, return the corresponding object. Otherwise, 
    124  * return the statically allocated p_vlc object. 
    125  *****************************************************************************/ 
    126 libvlc_int_t * vlc_current_object( int i_object ) 
    127 { 
    128     if( i_object ) 
    129     { 
    130          return vlc_object_get( p_libvlc_global, i_object ); 
    131     } 
    132  
    133     return p_static_vlc; 
    134 } 
    13548 
    13649/***************************************************************************** 
    …… 
    18598int VLC_Create( void ) 
    18699{ 
    187     int i_ret; 
    188     libvlc_int_t * p_libvlc = NULL; 
    189     vlc_value_t lockval; 
    190  
    191     /* &libvlc never changes, so we can safely call this multiple times. */ 
    192     p_libvlc_global = &libvlc_global; 
    193  
    194     /* vlc_threads_init *must* be the first internal call! No other call is 
    195      * allowed before the thread system has been initialized. */ 
    196     i_ret = vlc_threads_init( p_libvlc_global ); 
    197     if( i_ret < 0 ) 
    198     { 
    199         return i_ret; 
    200     } 
    201  
    202     /* Now that the thread system is initialized, we don't have much, but 
    203      * at least we have var_Create */ 
    204     var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); 
    205     var_Get( p_libvlc_global, "libvlc", &lockval ); 
    206     vlc_mutex_lock( lockval.p_address ); 
    207     if( !libvlc_global.b_ready ) 
    208     { 
    209         char *psz_env; 
    210  
    211         /* Guess what CPU we have */ 
    212         libvlc_global.i_cpu = CPUCapabilities(); 
    213  
    214         /* Find verbosity from VLC_VERBOSE environment variable */ 
    215         psz_env = getenv( "VLC_VERBOSE" ); 
    216         libvlc_global.i_verbose = psz_env ? atoi( psz_env ) : -1; 
    217  
    218 #if defined( HAVE_ISATTY ) && !defined( WIN32 ) 
    219         libvlc_global.b_color = isatty( 2 ); /* 2 is for stderr */ 
    220 #else 
    221         libvlc_global.b_color = VLC_FALSE; 
    222 #endif 
    223  
    224         /* Initialize message queue */ 
    225         msg_Create( p_libvlc_global ); 
    226  
    227         /* Announce who we are */ 
    228         msg_Dbg( p_libvlc_global, COPYRIGHT_MESSAGE ); 
    229         msg_Dbg( p_libvlc_global, "libvlc was configured with %s", 
    230                                 CONFIGURE_LINE ); 
    231  
    232         /* The module bank will be initialized later */ 
    233         libvlc_global.p_module_bank = NULL; 
    234  
    235         libvlc_global.b_ready = VLC_TRUE; 
    236     } 
    237     vlc_mutex_unlock( lockval.p_address ); 
    238     var_Destroy( p_libvlc_global, "libvlc" ); 
    239  
    240     /* Allocate a vlc object */ 
    241     p_libvlc = vlc_object_create( p_libvlc_global, VLC_OBJECT_LIBVLC ); 
    242     if( p_libvlc == NULL ) 
    243     { 
    244         return VLC_EGENERIC; 
    245     } 
    246     p_libvlc->thread_id = 0; 
    247     p_libvlc->p_playlist = NULL; 
    248     p_libvlc->psz_object_name = "libvlc"; 
    249  
    250     /* Initialize mutexes */ 
    251     vlc_mutex_init( p_libvlc, &p_libvlc->config_lock ); 
    252 #ifdef __APPLE__ 
    253     vlc_mutex_init( p_libvlc, &p_libvlc->quicktime_lock ); 
    254     vlc_thread_set_priority( p_libvlc, VLC_THREAD_PRIORITY_LOW ); 
    255 #endif 
    256  
    257     /* Store our newly allocated structure in the global list */ 
    258     vlc_object_attach( p_libvlc, p_libvlc_global ); 
    259  
    260     /* Store data for the non-reentrant API */ 
    261     p_static_vlc = p_libvlc; 
    262  
    263     return p_libvlc->i_object_id; 
     100    libvlc_int_t *p_object = libvlc_InternalCreate(); 
     101    if( p_object ) return p_object->i_object_id; 
     102    return VLC_ENOOBJ; 
    264103} 
    265104 
    …… 
    282121int VLC_Init( int i_object, int i_argc, char *ppsz_argv[] ) 
    283122{ 
    284     char         p_capabilities[200]; 
    285     char *       p_tmp; 
    286     char *       psz_modules; 
    287     char *       psz_parser; 
    288     char *       psz_control; 
    289     vlc_bool_t   b_exit = VLC_FALSE; 
    290     int          i_ret = VLC_EEXIT; 
    291     module_t    *p_help_module; 
    292     playlist_t  *p_playlist; 
    293     vlc_value_t  val; 
    294 #if defined( ENABLE_NLS ) \ 
    295      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) 
    296 # if defined (WIN32) || defined (__APPLE__) 
    297     char *       psz_language; 
    298 #endif 
    299 #endif 
    300     LIBVLC_FUNC; 
    301  
    302     /* System specific initialization code */ 
    303     system_Init( p_libvlc, &i_argc, ppsz_argv ); 
    304  
    305     /* Get the executable name (similar to the basename command) */ 
    306     if( i_argc > 0 ) 
    307     { 
    308         p_libvlc->psz_object_name = p_tmp = ppsz_argv[ 0 ]; 
    309         while( *p_tmp ) 
    310         { 
    311             if( *p_tmp == '/' ) p_libvlc->psz_object_name = ++p_tmp; 
    312             else ++p_tmp; 
    313         } 
    314     } 
    315     else 
    316     { 
    317         p_libvlc->psz_object_name = "vlc"; 
    318     } 
    319  
    320     /* 
    321      * Support for gettext 
    322      */ 
    323     SetLanguage( "" ); 
    324  
    325     /* 
    326      * Global iconv, must be done after setlocale() 
    327      * so that vlc_current_charset() works. 
    328      */ 
    329     LocaleInit( (vlc_object_t *)p_libvlc ); 
    330  
    331     /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */ 
    332     msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") ); 
    333  
    334     /* Initialize the module bank and load the configuration of the 
    335      * main module. We need to do this at this stage to be able to display 
    336      * a short help if required by the user. (short help == main module 
    337      * options) */ 
    338     module_InitBank( p_libvlc ); 
    339  
    340     /* Hack: insert the help module here */ 
    341     p_help_module = vlc_object_create( p_libvlc, VLC_OBJECT_MODULE ); 
    342     if( p_help_module == NULL ) 
    343     { 
    344         module_EndBank( p_libvlc ); 
    345         if( i_object ) vlc_object_release( p_libvlc ); 
    346         return VLC_EGENERIC; 
    347     } 
    348     p_help_module->psz_object_name = "help"; 
    349     p_help_module->psz_longname = N_("Help options"); 
    350     config_Duplicate( p_help_module, p_help_config ); 
    351     vlc_object_attach( p_help_module, libvlc_global.p_module_bank ); 
    352     /* End hack */ 
    353  
    354     if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, VLC_TRUE ) ) 
    355     { 
    356         vlc_object_detach( p_help_module ); 
    357         config_Free( p_help_module ); 
    358         vlc_object_destroy( p_help_module ); 
    359         module_EndBank( p_libvlc ); 
    360         if( i_object ) vlc_object_release( p_libvlc ); 
    361         return VLC_EGENERIC; 
    362     } 
    363  
    364     /* Check for short help option */ 
    365     if( config_GetInt( p_libvlc, "help" ) ) 
    366     { 
    367         Help( p_libvlc, "help" ); 
    368         b_exit = VLC_TRUE; 
    369         i_ret = VLC_EEXITSUCCESS; 
    370     } 
    371     /* Check for version option */ 
    372     else if( config_GetInt( p_libvlc, "version" ) ) 
    373     { 
    374         Version(); 
    375         b_exit = VLC_TRUE; 
    376         i_ret = VLC_EEXITSUCCESS; 
    377     } 
    378  
    379     /* Set the config file stuff */ 
    380     p_libvlc->psz_homedir = config_GetHomeDir(); 
    381     p_libvlc->psz_userdir = config_GetUserDir(); 
    382     if( p_libvlc->psz_userdir == NULL ) 
    383         p_libvlc->psz_userdir = strdup(p_libvlc->psz_homedir); 
    384     p_libvlc->psz_configfile = config_GetPsz( p_libvlc, "config" ); 
    385     if( p_libvlc->psz_configfile != NULL && p_libvlc->psz_configfile[0] == '~' 
    386          && p_libvlc->psz_configfile[1] == '/' ) 
    387     { 
    388         char *psz = malloc( strlen(p_libvlc->psz_userdir) 
    389                              + strlen(p_libvlc->psz_configfile) ); 
    390         /* This is incomplete : we should also support the ~cmassiot/ syntax. */ 
    391         sprintf( psz, "%s/%s", p_libvlc->psz_userdir, 
    392                                p_libvlc->psz_configfile + 2 ); 
    393         free( p_libvlc->psz_configfile ); 
    394         p_libvlc->psz_configfile = psz; 
    395     } 
    396  
    397     /* Check for plugins cache options */ 
    398     if( config_GetInt( p_libvlc, "reset-plugins-cache" ) ) 
    399     { 
    400         libvlc_global.p_module_bank->b_cache_delete = VLC_TRUE; 
    401     } 
    402  
    403     /* Hack: remove the help module here */ 
    404     vlc_object_detach( p_help_module ); 
    405     /* End hack */ 
    406  
    407     /* Will be re-done properly later on */ 
    408     p_libvlc->p_libvlc_global->i_verbose = config_GetInt( p_libvlc, "verbose" ); 
    409  
    410     /* Check for daemon mode */ 
    411 #ifndef WIN32 
    412     if( config_GetInt( p_libvlc, "daemon" ) ) 
    413     { 
    414 #if HAVE_DAEMON 
    415         if( daemon( 1, 0) != 0 ) 
    416         { 
    417             msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" ); 
    418             b_exit = VLC_TRUE; 
    419         } 
    420  
    421         p_libvlc->p_libvlc_global->b_daemon = VLC_TRUE; 
    422  
    423         /* lets check if we need to write the pidfile */ 
    424         char * psz_pidfile = config_GetPsz( p_libvlc, "pidfile" ); 
    425          
    426         msg_Dbg( p_libvlc, "psz_pidfile is %s", psz_pidfile ); 
    427          
    428         if( psz_pidfile != NULL ) 
    429         { 
    430             FILE *pidfile; 
    431             pid_t i_pid = getpid (); 
    432              
    433             msg_Dbg( p_libvlc, "our PID is %d, writing it to %s", i_pid, psz_pidfile ); 
    434              
    435             pidfile = utf8_fopen( psz_pidfile,"w" ); 
    436             if( pidfile != NULL ) 
    437             { 
    438                 utf8_fprintf( pidfile, "%d", (int)i_pid ); 
    439                 fclose( pidfile ); 
    440             } 
    441             else 
    442             { 
    443                 msg_Err( p_libvlc, "Cannot open pid file for writing: %s, error: %s",  
    444                         psz_pidfile, strerror(errno) ); 
    445             } 
    446         } 
    447  
    448         free( psz_pidfile ); 
    449  
    450 #else 
    451         pid_t i_pid; 
    452  
    453         if( ( i_pid = fork() ) < 0 ) 
    454         { 
    455             msg_Err( p_libvlc, "Unable to fork vlc to daemon mode" ); 
    456             b_exit = VLC_TRUE; 
    457         } 
    458         else if( i_pid ) 
    459         { 
    460             /* This is the parent, exit right now */ 
    461             msg_Dbg( p_libvlc, "closing parent process" ); 
    462             b_exit = VLC_TRUE; 
    463             i_ret = VLC_EEXITSUCCESS; 
    464         } 
    465         else 
    466         { 
    467             /* We are the child */ 
    468             msg_Dbg( p_libvlc, "daemon spawned" ); 
    469             close( STDIN_FILENO ); 
    470             close( STDOUT_FILENO ); 
    471             close( STDERR_FILENO ); 
    472  
    473             p_libvlc->p_libvlc_global->b_daemon = VLC_TRUE; 
    474         } 
    475 #endif 
    476     } 
    477 #endif 
    478  
    479     if( b_exit ) 
    480     { 
    481         config_Free( p_help_module ); 
    482         vlc_object_destroy( p_help_module ); 
    483         module_EndBank( p_libvlc ); 
    484         if( i_object ) vlc_object_release( p_libvlc ); 
    485         return i_ret; 
    486     } 
    487  
    488     /* Check for translation config option */ 
    489 #if defined( ENABLE_NLS ) \ 
    490      && ( defined( HAVE_GETTEXT ) || defined( HAVE_INCLUDED_GETTEXT ) ) 
    491 # if defined (WIN32) || defined (__APPLE__) 
    492     /* This ain't really nice to have to reload the config here but it seems 
    493      * the only way to do it. */ 
    494     config_LoadConfigFile( p_libvlc, "main" ); 
    495     config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, VLC_TRUE ); 
    496  
    497     /* Check if the user specified a custom language */ 
    498     psz_language = config_GetPsz( p_libvlc, "language" ); 
    499     if( psz_language && *psz_language && strcmp( psz_language, "auto" ) ) 
    500     { 
    501         vlc_bool_t b_cache_delete = libvlc_global.p_module_bank->b_cache_delete; 
    502  
    503         /* Reset the default domain */ 
    504         SetLanguage( psz_language ); 
    505  
    506         /* Translate "C" to the language code: "fr", "en_GB", "nl", "ru"... */ 
    507         msg_Dbg( p_libvlc, "translation test: code is \"%s\"", _("C") ); 
    508  
    509         module_EndBank( p_libvlc ); 
    510         module_InitBank( p_libvlc ); 
    511         config_LoadConfigFile( p_libvlc, "main" ); 
    512         config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, VLC_TRUE ); 
    513         libvlc_global.p_module_bank->b_cache_delete = b_cache_delete; 
    514     } 
    515     if( psz_language ) free( psz_language ); 
    516 # endif 
    517 #endif 
    518  
    519     /* 
    520      * Load the builtins and plugins into the module_bank. 
    521      * We have to do it before config_Load*() because this also gets the 
    522      * list of configuration options exported by each module and loads their 
    523      * default values. 
    524      */ 
    525     module_LoadBuiltins( p_libvlc ); 
    526     module_LoadPlugins( p_libvlc ); 
    527     if( p_libvlc->b_die ) 
    528     { 
    529         b_exit = VLC_TRUE; 
    530     } 
    531  
    532     msg_Dbg( p_libvlc, "module bank initialized, found %i modules", 
    533                     libvlc_global.p_module_bank->i_children ); 
    534  
    535     /* Hack: insert the help module here */ 
    536     vlc_object_attach( p_help_module, libvlc_global.p_module_bank ); 
    537     /* End hack */ 
    538  
    539     /* Check for help on modules */ 
    540     if( (p_tmp = config_GetPsz( p_libvlc, "module" )) ) 
    541     { 
    542         Help( p_libvlc, p_tmp ); 
    543         free( p_tmp ); 
    544         b_exit = VLC_TRUE; 
    545         i_ret = VLC_EEXITSUCCESS; 
    546     } 
    547     /* Check for long help option */ 
    548     else if( config_GetInt( p_libvlc, "longhelp" ) ) 
    549     { 
    550         Help( p_libvlc, "longhelp" ); 
    551         b_exit = VLC_TRUE; 
    552         i_ret = VLC_EEXITSUCCESS; 
    553     } 
    554     /* Check for module list option */ 
    555     else if( config_GetInt( p_libvlc, "list" ) ) 
    556     { 
    557         ListModules( p_libvlc ); 
    558         b_exit = VLC_TRUE; 
    559         i_ret = VLC_EEXITSUCCESS; 
    560     } 
    561  
    562     /* Check for config file options */ 
    563     if( config_GetInt( p_libvlc, "reset-config" ) ) 
    564     { 
    565         vlc_object_detach( p_help_module ); 
    566         config_ResetAll( p_libvlc ); 
    567         config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, VLC_TRUE ); 
    568         config_SaveConfigFile( p_libvlc, NULL ); 
    569         vlc_object_attach( p_help_module, libvlc_global.p_module_bank ); 
    570     } 
    571     if( config_GetInt( p_libvlc, "save-config" ) ) 
    572     { 
    573         vlc_object_detach( p_help_module ); 
    574         config_LoadConfigFile( p_libvlc, NULL ); 
    575         config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, VLC_TRUE ); 
    576         config_SaveConfigFile( p_libvlc, NULL ); 
    577         vlc_object_attach( p_help_module, libvlc_global.p_module_bank ); 
    578     } 
    579  
    580     /* Hack: remove the help module here */ 
    581     vlc_object_detach( p_help_module ); 
    582     /* End hack */ 
    583  
    584     if( b_exit ) 
    585     { 
    586         config_Free( p_help_module ); 
    587         vlc_object_destroy( p_help_module ); 
    588         module_EndBank( p_libvlc ); 
    589         if( i_object ) vlc_object_release( p_libvlc ); 
    590         return i_ret; 
    591     } 
    592  
    593     /* 
    594      * Init device values 
    595      */ 
    596     InitDeviceValues( p_libvlc ); 
    597  
    598     /* 
    599      * Override default configuration with config file settings 
    600      */ 
    601     config_LoadConfigFile( p_libvlc, NULL ); 
    602  
    603     /* Hack: insert the help module here */ 
    604     vlc_object_attach( p_help_module, libvlc_global.p_module_bank ); 
    605     /* End hack */ 
    606  
    607     /* 
    608      * Override configuration with command line settings 
    609      */ 
    610     if( config_LoadCmdLine( p_libvlc, &i_argc, ppsz_argv, VLC_FALSE ) ) 
    611     { 
    612 #ifdef WIN32 
    613         ShowConsole( VLC_FALSE ); 
    614         /* Pause the console because it's destroyed when we exit */ 
    615         fprintf( stderr, "The command line options couldn't be loaded, check " 
    616                  "that they are valid.\n" ); 
    617         PauseConsole(); 
    618 #endif 
    619         vlc_object_detach( p_help_module ); 
    620         config_Free( p_help_module ); 
    621         vlc_object_destroy( p_help_module ); 
    622         module_EndBank( p_libvlc ); 
    623         if( i_object ) vlc_object_release( p_libvlc ); 
    624         return VLC_EGENERIC; 
    625     } 
    626  
    627     /* Hack: remove the help module here */ 
    628     vlc_object_detach( p_help_module ); 
    629     config_Free( p_help_module ); 
    630     vlc_object_destroy( p_help_module ); 
    631     /* End hack */ 
    632  
    633     /* 
    634      * System specific configuration 
    635      */ 
    636     system_Configure( p_libvlc, &i_argc, ppsz_argv ); 
    637  
    638     /* 
    639      * Message queue options 
    640      */ 
    641  
    642     var_Create( p_libvlc, "verbose", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); 
    643     if( config_GetInt( p_libvlc, "quiet" ) ) 
    644     { 
    645         val.i_int = -1; 
    646         var_Set( p_libvlc, "verbose", val ); 
    647     } 
    648     var_AddCallback( p_libvlc, "verbose", VerboseCallback, NULL ); 
    649     var_Change( p_libvlc, "verbose", VLC_VAR_TRIGGER_CALLBACKS, NULL, NULL ); 
    650  
    651     libvlc_global.b_color = libvlc_global.b_color &&  
    652                                 config_GetInt( p_libvlc, "color" ); 
    653  
    654     /* 
    655      * Output messages that may still be in the queue 
    656      */ 
    657     msg_Flush( p_libvlc ); 
    658  
    659     /* p_libvlc initialization. FIXME ? */ 
    660  
    661     if( !config_GetInt( p_libvlc, "fpu" ) ) 
    662         libvlc_global.i_cpu &= ~CPU_CAPABILITY_FPU; 
    663  
    664 #if defined( __i386__ ) || defined( __x86_64__ ) 
    665     if( !config_GetInt( p_libvlc, "mmx" ) ) 
    666         libvlc_global.i_cpu &= ~CPU_CAPABILITY_MMX; 
    667     if( !config_GetInt( p_libvlc, "3dn" ) ) 
    668         libvlc_global.i_cpu &= ~CPU_CAPABILITY_3DNOW; 
    669     if( !config_GetInt( p_libvlc, "mmxext" ) ) 
    670         libvlc_global.i_cpu &= ~CPU_CAPABILITY_MMXEXT; 
    671     if( !config_GetInt( p_libvlc, "sse" ) ) 
    672         libvlc_global.i_cpu &= ~CPU_CAPABILITY_SSE; 
    673     if( !config_GetInt( p_libvlc, "sse2" ) ) 
    674         libvlc_global.i_cpu &= ~CPU_CAPABILITY_SSE2; 
    675 #endif 
    676 #if defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ ) 
    677     if( !config_GetInt( p_libvlc, "altivec" ) ) 
    678         libvlc_global.i_cpu &= ~CPU_CAPABILITY_ALTIVEC; 
    679 #endif 
    680  
    681 #define PRINT_CAPABILITY( capability, string )                              \ 
    682     if( libvlc_global.i_cpu & capability )                                         \ 
    683     {                                                                       \ 
    684         strncat( p_capabilities, string " ",                                \ 
    685                  sizeof(p_capabilities) - strlen(p_capabilities) );         \ 
    686         p_capabilities[sizeof(p_capabilities) - 1] = '\0';                  \ 
    687     } 
    688  
    689     p_capabilities[0] = '\0'; 
    690     PRINT_CAPABILITY( CPU_CAPABILITY_486, "486" ); 
    691     PRINT_CAPABILITY( CPU_CAPABILITY_586, "586" ); 
    692     PRINT_CAPABILITY( CPU_CAPABILITY_PPRO, "Pentium Pro" ); 
    693     PRINT_CAPABILITY( CPU_CAPABILITY_MMX, "MMX" ); 
    694     PRINT_CAPABILITY( CPU_CAPABILITY_3DNOW, "3DNow!" ); 
    695     PRINT_CAPABILITY( CPU_CAPABILITY_MMXEXT, "MMXEXT" ); 
    696     PRINT_CAPABILITY( CPU_CAPABILITY_SSE, "SSE" ); 
    697     PRINT_CAPABILITY( CPU_CAPABILITY_SSE2, "SSE2" ); 
    698     PRINT_CAPABILITY( CPU_CAPABILITY_ALTIVEC, "AltiVec" ); 
    699     PRINT_CAPABILITY( CPU_CAPABILITY_FPU, "FPU" ); 
    700     msg_Dbg( p_libvlc, "CPU has capabilities %s", p_capabilities ); 
    701  
    702     /* 
    703      * Choose the best memcpy module 
    704      */ 
    705     p_libvlc->p_memcpy_module = module_Need( p_libvlc, "memcpy", "$memcpy", 0 ); 
    706  
    707     if( p_libvlc->pf_memcpy == NULL ) 
    708     { 
    709         p_libvlc->pf_memcpy = memcpy; 
    710     } 
    711  
    712     if( p_libvlc->pf_memset == NULL ) 
    713     { 
    714         p_libvlc->pf_memset = memset; 
    715     } 
    716  
    717     p_libvlc->b_stats = config_GetInt( p_libvlc, "stats" ); 
    718     p_libvlc->i_timers = 0; 
    719     p_libvlc->pp_timers = NULL; 
    720     vlc_mutex_init( p_libvlc, &p_libvlc->timer_lock ); 
    721  
    722     /* 
    723      * Initialize hotkey handling 
    724      */ 
    725     var_Create( p_libvlc, "key-pressed", VLC_VAR_INTEGER ); 
    726     p_libvlc->p_hotkeys = malloc( sizeof(p_hotkeys) ); 
    727     /* Do a copy (we don't need to modify the strings) */ 
    728     memcpy( p_libvlc->p_hotkeys, p_hotkeys, sizeof(p_hotkeys) ); 
    729  
    730     /* Initialize playlist and get commandline files */ 
    731     playlist_ThreadCreate( p_libvlc ); 
    732     if( !p_libvlc->p_playlist ) 
    733     { 
    734         msg_Err( p_libvlc, "playlist initialization failed" ); 
    735         if( p_libvlc->p_memcpy_module != NULL ) 
    736         { 
    737             module_Unneed( p_libvlc, p_libvlc->p_memcpy_module ); 
    738         } 
    739         module_EndBank( p_libvlc ); 
    740         if( i_object ) vlc_object_release( p_libvlc ); 
    741         return VLC_EGENERIC; 
    742     } 
    743     p_playlist = p_libvlc->p_playlist; 
    744  
    745     psz_modules = config_GetPsz( p_playlist, "services-discovery" ); 
    746     if( psz_modules && *psz_modules ) 
    747     { 
    748         /* Add service discovery modules */ 
    749         playlist_AddSDModules( p_playlist, psz_modules ); 
    750     } 
    751     if( psz_modules ) free( psz_modules ); 
    752  
    753     /* 
    754      * Load background interfaces 
    755      */ 
    756     psz_modules = config_GetPsz( p_libvlc, "extraintf" ); 
    757     psz_control = config_GetPsz( p_libvlc, "control" ); 
    758  
    759     if( psz_modules && *psz_modules && psz_control && *psz_control ) 
    760     { 
    761         psz_modules = (char *)realloc( psz_modules, strlen( psz_modules ) + 
    762                                                     strlen( psz_control ) + 1 ); 
    763         sprintf( psz_modules, "%s:%s", psz_modules, psz_control ); 
    764     } 
    765     else if( psz_control && *psz_control ) 
    766     { 
    767         if( psz_modules ) free( psz_modules ); 
    768         psz_modules = strdup( psz_control ); 
    769     } 
    770  
    771     psz_parser = psz_modules; 
    772     while ( psz_parser && *psz_parser ) 
    773     { 
    774         char *psz_module, *psz_temp; 
    775         psz_module = psz_parser; 
    776         psz_parser = strchr( psz_module, ':' ); 
    777         if ( psz_parser ) 
    778         { 
    779             *psz_parser = '\0'; 
    780             psz_parser++; 
    781         } 
    782         psz_temp = (char *)malloc( strlen(psz_module) + sizeof(",none") ); 
    783         if( psz_temp ) 
    784         { 
    785             sprintf( psz_temp, "%s,none", psz_module ); 
    786             VLC_AddIntf( 0, psz_temp, VLC_FALSE, VLC_FALSE ); 
    787             free( psz_temp ); 
    788         } 
    789     } 
    790     if ( psz_modules ) 
    791     { 
    792         free( psz_modules ); 
    793     } 
    794  
    795     /* 
    796      * Always load the hotkeys interface if it exists 
    797      */ 
    798     VLC_AddIntf( 0, "hotkeys,none", VLC_FALSE, VLC_FALSE ); 
    799  
    800     /* 
    801      * If needed, load the Xscreensaver interface 
    802      * Currently, only for X 
    803      */ 
    804 #ifdef HAVE_X11_XLIB_H 
    805     if( config_GetInt( p_libvlc, "disable-screensaver" ) == 1 ) 
    806     { 
    807         VLC_AddIntf( 0, "screensaver,none", VLC_FALSE, VLC_FALSE ); 
    808     } 
    809 #endif 
    810  
    811     if( config_GetInt( p_libvlc, "file-logging" ) == 1 ) 
    812     { 
    813         VLC_AddIntf( 0, "logger,none", VLC_FALSE, VLC_FALSE ); 
    814     } 
    815 #ifdef HAVE_SYSLOG_H 
    816     if( config_GetInt( p_libvlc, "syslog" ) == 1 ) 
    817     { 
    818         char *psz_logmode = "logmode=syslog"; 
    819         AddIntfInternal( 0, "logger,none", VLC_FALSE, VLC_FALSE, 1, &psz_logmode ); 
    820     } 
    821 #endif 
    822  
    823     if( config_GetInt( p_libvlc, "show-intf" ) == 1 ) 
    824     { 
    825         VLC_AddIntf( 0, "showintf,none", VLC_FALSE, VLC_FALSE ); 
    826     } 
    827  
    828     if( config_GetInt( p_libvlc, "network-synchronisation") == 1 ) 
    829     { 
    830         VLC_AddIntf( 0, "netsync,none", VLC_FALSE, VLC_FALSE ); 
    831     } 
    832  
    833     /* 
    834      * FIXME: kludge to use a p_libvlc-local variable for the Mozilla plugin 
    835      */ 
    836     var_Create( p_libvlc, "drawable", VLC_VAR_INTEGER ); 
    837     var_Create( p_libvlc, "drawable-view-top", VLC_VAR_INTEGER ); 
    838     var_Create( p_libvlc, "drawable-view-left", VLC_VAR_INTEGER ); 
    839     var_Create( p_libvlc, "drawable-view-bottom", VLC_VAR_INTEGER ); 
    840     var_Create( p_libvlc, "drawable-view-right", VLC_VAR_INTEGER ); 
    841     var_Create( p_libvlc, "drawable-clip-top", VLC_VAR_INTEGER ); 
    842     var_Create( p_libvlc, "drawable-clip-left", VLC_VAR_INTEGER ); 
    843     var_Create( p_libvlc, "drawable-clip-bottom", VLC_VAR_INTEGER ); 
    844     var_Create( p_libvlc, "drawable-clip-right", VLC_VAR_INTEGER ); 
    845  
    846     /* Create volume callback system. */ 
    847     var_Create( p_libvlc, "volume-change", VLC_VAR_BOOL ); 
    848  
    849     /* 
    850      * Get input filenames given as commandline arguments 
    851      */ 
    852     GetFilenames( p_libvlc, i_argc, ppsz_argv ); 
    853  
    854     /* 
    855      * Get --open argument 
    856      */ 
    857     var_Create( p_libvlc, "open", VLC_VAR_STRING | VLC_VAR_DOINHERIT ); 
    858     var_Get( p_libvlc, "open", &val ); 
    859     if ( val.psz_string != NULL && *val.psz_string ) 
    860     { 
    861         VLC_AddTarget( p_libvlc->i_object_id, val.psz_string, NULL, 0, 
    862                        PLAYLIST_INSERT, 0 ); 
    863     } 
    864     if ( val.psz_string != NULL ) free( val.psz_string ); 
    865  
    866     LIBVLC_FUNC_END; 
    867     return VLC_SUCCESS; 
     123    int i_ret; 
     124    LIBVLC_FUNC; 
     125    i_ret = libvlc_InternalInit( p_libvlc, i_argc, ppsz_argv ); 
     126    LIBVLC_FUNC_END; 
     127    return i_ret; 
    868128} 
    869129 
    …… 
    880140                 vlc_bool_t b_block, vlc_bool_t b_play ) 
    881141{ 
    882     return AddIntfInternal( i_object, psz_module, b_block, b_play, 0, NULL ); 
     142    int i_ret; 
     143    LIBVLC_FUNC; 
     144    i_ret = libvlc_InternalAddIntf( p_libvlc, psz_module, b_block, b_play, 
     145                                    0, NULL ); 
     146    LIBVLC_FUNC_END; 
     147    return i_ret; 
    883148} 
    884149 
    …… 
    903168int VLC_CleanUp( int i_object ) 
    904169{ 
    905     intf_thread_t      * p_intf; 
    906     playlist_t         * p_playlist; 
    907     vout_thread_t      * p_vout; 
    908     aout_instance_t    * p_aout; 
    909     announce_handler_t * p_announce; 
    910      
    911     LIBVLC_FUNC; 
    912  
    913     /* Ask the interfaces to stop and destroy them */ 
    914     msg_Dbg( p_libvlc, "removing all interfaces" ); 
    915     while( (p_intf = vlc_object_find( p_libvlc, VLC_OBJECT_INTF, FIND_CHILD )) ) 
    916     { 
    917         intf_StopThread( p_intf ); 
    918         vlc_object_detach( p_intf ); 
    919         vlc_object_release( p_intf ); 
    920         intf_Destroy( p_intf ); 
    921     } 
    922  
    923     /* Free playlist */ 
    924     msg_Dbg( p_libvlc, "removing playlist" ); 
    925     playlist_ThreadDestroy( p_libvlc->p_playlist ); 
    926  
    927     /* Free video outputs */ 
    928     msg_Dbg( p_libvlc, "removing all video outputs" ); 
    929     while( (p_vout = vlc_object_find( p_libvlc, VLC_OBJECT_VOUT, FIND_CHILD )) ) 
    930     { 
    931         vlc_object_detach( p_vout ); 
    932         vlc_object_release( p_vout ); 
    933         vout_Destroy( p_vout ); 
    934     } 
    935  
    936     /* Free audio outputs */ 
    937     msg_Dbg( p_libvlc, "removing all audio outputs" ); 
    938     while( (p_aout = vlc_object_find( p_libvlc, VLC_OBJECT_AOUT, FIND_CHILD )) ) 
    939     { 
    940         vlc_object_detach( (vlc_object_t *)p_aout ); 
    941         vlc_object_release( (vlc_object_t *)p_aout ); 
    942         aout_Delete( p_aout ); 
    943     } 
    944  
    945     stats_TimersDumpAll( p_libvlc ); 
    946     stats_TimersClean( p_libvlc ); 
    947  
    948     /* Free announce handler(s?) */ 
    949     while( (p_announce = vlc_object_find( p_libvlc, VLC_OBJECT_ANNOUNCE, 
    950                                                  FIND_CHILD ) ) ) 
    951     { 
    952         msg_Dbg( p_libvlc, "removing announce handler" ); 
    953         vlc_object_detach( p_announce ); 
    954         vlc_object_release( p_announce ); 
    955         announce_HandlerDestroy( p_announce ); 
    956     } 
    957  
    958     LIBVLC_FUNC_END; 
     170    int i_ret; 
     171    LIBVLC_FUNC; 
     172    i_ret = libvlc_InternalCleanup( p_libvlc ); 
     173    LIBVLC_FUNC_END; 
     174    return i_ret; 
    959175} 
    960176 
    …… 
    968184{ 
    969185    LIBVLC_FUNC; 
    970      
    971     /* Free allocated memory */ 
    972     if( p_libvlc->p_memcpy_module ) 
    973     { 
    974         module_Unneed( p_libvlc, p_libvlc->p_memcpy_module ); 
    975         p_libvlc->p_memcpy_module = NULL; 
    976     } 
    977  
    978     /* Free module bank !  */ 
    979     module_EndBank( p_libvlc ); 
    980  
    981     FREENULL( p_libvlc->psz_homedir ); 
    982     FREENULL( p_libvlc->psz_userdir ); 
    983     FREENULL( p_libvlc->psz_configfile ); 
    984     FREENULL( p_libvlc->p_hotkeys ); 
    985  
    986     /* System specific cleaning code */ 
    987     system_End( p_libvlc ); 
    988  
    989     /* 
    990      * Free message queue. 
    991      * Nobody shall use msg_* afterward. 
    992      */ 
    993     msg_Flush( p_libvlc ); 
    994     msg_Destroy( p_libvlc_global ); 
    995  
    996     /* Destroy global iconv */ 
    997     LocaleDeinit(); 
    998  
    999     /* Destroy mutexes */ 
    1000     vlc_mutex_destroy( &p_libvlc->config_lock ); 
    1001  
    1002     vlc_object_detach( p_libvlc ); 
    1003  
    1004     /* Release object before destroying it */ 
    1005     if( i_object ) vlc_object_release( p_libvlc ); 
    1006  
    1007     vlc_object_destroy( p_libvlc ); 
    1008  
    1009     /* Stop thread system: last one out please shut the door! */ 
    1010     vlc_threads_end( p_libvlc_global ); 
    1011  
    1012     return VLC_SUCCESS; 
     186    return libvlc_InternalDestroy( p_libvlc, VLC_TRUE ); 
    1013187} 
    1014188 
    …… 
    1216390    input_thread_t *p_input; 
    1217391    vlc_value_t val; 
    1218     libvlc_int_t *p_libvlc = vlc_current_object( i_object ); 
    1219  
    1220     /* Check that the handle is valid */ 
    1221     if( !p_libvlc ) 
    1222     { 
    1223         return VLC_ENOOBJ; 
    1224     } 
     392    LIBVLC_FUNC; 
    1225393 
    1226394    p_input = vlc_object_find( p_libvlc, VLC_OBJECT_INPUT, FIND_CHILD ); 
    …… 
    1235403    vlc_object_release( p_input ); 
    1236404 
    1237     if( i_object ) vlc_object_release( p_libvlc ); 
     405    LIBVLC_FUNC_END; 
    1238406    return val.f_float; 
    1239407} 
    …… 
    1494662 
    1495663/** 
    1496  * Total amount of items in the playlist 
     664 * Total number of items in the playlist 
    1497665 * 
    1498666 * \param i_object a vlc object id 
    …… 
    1502670{ 
    1503671    int i_size; 
    1504     playlist_t * p_playlist; 
    1505     libvlc_int_t *p_libvlc = vlc_current_object( i_object ); 
    1506  
    1507     /* Check that the handle is valid */ 
    1508     if( !p_libvlc ) 
    1509     { 
    1510         return VLC_ENOOBJ; 
    1511     } 
    1512  
    1513     p_playlist = vlc_object_find( p_libvlc, VLC_OBJECT_PLAYLIST, FIND_CHILD ); 
    1514  
    1515     if( !p_playlist ) 
    1516     { 
    1517         if( i_object ) vlc_object_release( p_libvlc ); 
    1518         return VLC_ENOOBJ; 
    1519     } 
    1520  
    1521     i_size = p_playlist->i_size; 
    1522     vlc_object_release( p_playlist ); 
    1523  
    1524     if( i_object ) vlc_object_release( p_libvlc ); 
     672    LIBVLC_PLAYLIST_FUNC; 
     673    i_size = p_libvlc->p_playlist->i_size; 
     674    LIBVLC_PLAYLIST_FUNC_END; 
    1525675    return i_size; 
    1526676} 
    1527677 
    1528678/** 
    1529  * Next playlist item 
    1530  * 
    1531  * Skip to the next playlistitem and play it. 
    1532  * 
     679 * Go to next playlist item 
    1533680 * \param i_object a vlc object id 
    1534681 * \return VLC_SUCCESS on success 
    …… 
    1536683int VLC_PlaylistNext( int i_object ) 
    1537684{ 
    1538     playlist_t * p_playlist; 
    1539     libvlc_int_t *p_libvlc = vlc_current_object( i_object ); 
    1540  
    1541     /* Check that the handle is valid */ 
    1542     if( !p_libvlc ) 
    1543     { 
    1544         return VLC_ENOOBJ; 
    1545     } 
    1546  
    1547     p_playlist = vlc_object_find( p_libvlc, VLC_OBJECT_PLAYLIST, FIND_CHILD ); 
    1548  
    1549     if( !p_playlist ) 
    1550     { 
    1551         if( i_object ) vlc_object_release( p_libvlc ); 
    1552         return VLC_ENOOBJ; 
    1553     } 
    1554  
    1555     playlist_Next( p_playlist ); 
    1556     vlc_object_release( p_playlist ); 
    1557  
    1558     if( i_object ) vlc_object_release( p_libvlc ); 
    1559     return VLC_SUCCESS; 
    1560 } 
    1561  
    1562 /** 
    1563  * Previous playlist item 
    1564  * 
    1565  * Skip to the previous playlistitem and play it. 
    1566  * 
     685    LIBVLC_PLAYLIST_FUNC; 
     686    playlist_Next( p_libvlc->p_playlist ); 
     687    LIBVLC_PLAYLIST_FUNC_END; 
     688    return VLC_SUCCESS; 
     689} 
     690 
     691/** 
     692 * Go to previous playlist item 
    1567693 * \param i_object a vlc object id 
    1568694 * \return VLC_SUCCESS on success 
    …… 
    1570696int VLC_PlaylistPrev( int i_object ) 
    1571697{ 
    1572     playlist_t * p_playlist; 
    1573     libvlc_int_t *p_libvlc = vlc_current_object( i_object ); 
    1574  
    1575     /* Check that the handle is valid */ 
    1576     if( !p_libvlc ) 
    1577     { 
    1578         return VLC_ENOOBJ; 
    1579     } 
    1580  
    1581     p_playlist = vlc_object_find( p_libvlc, VLC_OBJECT_PLAYLIST, FIND_CHILD ); 
    1582  
    1583     if( !p_playlist ) 
    1584     { 
    1585         if( i_object ) vlc_object_release( p_libvlc ); 
    1586         return VLC_ENOOBJ; 
    1587     } 
    1588  
    1589     playlist_Prev( p_playlist ); 
    1590     vlc_object_release( p_playlist ); 
    1591  
    1592     if( i_object ) vlc_object_release( p_libvlc ); 
    1593     return VLC_SUCCESS; 
    1594 } 
    1595  
    1596  
    1597 /***************************************************************************** 
    1598  * VLC_PlaylistClear: Empty the playlist 
    1599  *****************************************************************************/ 
     698    LIBVLC_PLAYLIST_FUNC; 
     699    playlist_Prev( p_libvlc->p_playlist ); 
     700    LIBVLC_PLAYLIST_FUNC_END; 
     701    return VLC_SUCCESS; 
     702} 
     703 
     704/** 
     705 * Empty the playlist 
     706 */ 
    1600707int VLC_PlaylistClear( int i_object ) 
    1601708{ 
    1602     playlist_t * p_playlist; 
    1603     libvlc_int_t *p_libvlc = vlc_current_object( i_object ); 
    1604  
    1605     /* Check that the handle is valid */ 
    1606     if( !p_libvlc ) 
    1607     { 
    1608         return VLC_ENOOBJ; 
    1609     } 
    1610  
    1611     p_playlist = vlc_object_find( p_libvlc, VLC_OBJECT_PLAYLIST, FIND_CHILD ); 
    1612  
    1613     if( !p_playlist ) 
    1614     { 
    1615         if( i_object ) vlc_object_release( p_libvlc ); 
    1616         return VLC_ENOOBJ; 
    1617     } 
    1618  
    1619     playlist_Clear( p_playlist ); 
    1620  
    1621     vlc_object_release( p_playlist ); 
    1622  
    1623     if( i_object ) vlc_object_release( p_libvlc ); 
     709    LIBVLC_PLAYLIST_FUNC; 
     710    playlist_Clear( p_libvlc->p_playlist ); 
     711    LIBVLC_PLAYLIST_FUNC_END; 
    1624712    return VLC_SUCCESS; 
    1625713} 
    …… 
    1635723{ 
    1636724    audio_volume_t i_vol = 0; 
    1637     libvlc_int_t *p_libvlc = vlc_current_object( i_object ); 
    1638  
    1639     /* Check that the handle is valid */ 
    1640     if( !p_libvlc ) 
    1641     { 
    1642         return VLC_ENOOBJ; 
    1643     } 
     725    LIBVLC_FUNC; 
    1644726 
    1645727    if( i_volume >= 0 && i_volume <= 200 )