X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fmodules.c;h=f3014036a52e9b27495a9da69d05bcfffa8a568e;hb=bf9b62a4ea50a2ac124711378775c1def87243ca;hp=7eb0fd67253cc603334c01b27b1216f3dd2875ee;hpb=cff6378dbeeac3caedf198868537f85ae80f4bee;p=vlc diff --git a/src/misc/modules.c b/src/misc/modules.c index 7eb0fd6725..f3014036a5 100644 --- a/src/misc/modules.c +++ b/src/misc/modules.c @@ -1,11 +1,12 @@ /***************************************************************************** - * modules.c : Built-in and plugin modules management functions + * modules.c : Builtin and plugin modules management functions ***************************************************************************** * Copyright (C) 2001 VideoLAN - * $Id: modules.c,v 1.36 2001/06/14 02:47:45 sam Exp $ + * $Id: modules.c,v 1.72 2002/07/20 18:01:43 sam Exp $ * * Authors: Samuel Hocevar * Ethan C. Baldridge + * Hans-Peter Jansen * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,9 +22,6 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. *****************************************************************************/ -#include "defs.h" - -#include "config.h" /* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS * is set to 64. Don't try to be cleverer. */ @@ -35,9 +33,9 @@ #include /* sprintf() */ #include /* strdup() */ -#if !defined( _MSC_VER ) +#include + #include -#endif #if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */ # include /* dlopen(), dlsym(), dlclose() */ @@ -45,189 +43,100 @@ #elif defined(HAVE_IMAGE_H) /* BeOS */ # include # define HAVE_DYNAMIC_PLUGINS -#elif defined(WIN32) && defined( __MINGW32__ ) +#elif defined(WIN32) # define HAVE_DYNAMIC_PLUGINS #else # undef HAVE_DYNAMIC_PLUGINS #endif -#ifdef SYS_BEOS -# include "beos_specific.h" -#endif - -#ifdef SYS_DARWIN1_3 -# include "darwin_specific.h" -#endif -#include "common.h" -#include "threads.h" -#include "mtime.h" -#include "tests.h" #include "netutils.h" -#include "modules.h" #include "interface.h" -#include "intf_msg.h" -#include "intf_playlist.h" +#include "vlc_playlist.h" +#include "intf_eject.h" #include "stream_control.h" #include "input_ext-intf.h" #include "input_ext-dec.h" -#include "input.h" -#include "input_netlist.h" -#include "mpeg_system.h" +#include "input_ext-plugins.h" #include "video.h" #include "video_output.h" #include "audio_output.h" +#include "iso_lang.h" + #ifdef HAVE_DYNAMIC_PLUGINS -# include "modules_core.h" +# include "modules_plugin.h" +#endif + +#if !defined( _MSC_VER ) +# include "modules_builtin.h" +#else +# include "modules_builtin_msvc.h" #endif -#include "modules_builtin.h" -#include "modules_export.h" -#include "main.h" +/***************************************************************************** + * Static variables + *****************************************************************************/ +DECLARE_MODULE_CAPABILITY_TABLE; /***************************************************************************** * Local prototypes *****************************************************************************/ #ifdef HAVE_DYNAMIC_PLUGINS -static int AllocatePluginModule ( char * ); -#endif -#ifdef ALLOCATE_ALL_BUILTINS -static int AllocateBuiltinModule( int ( * ) ( module_t * ), - int ( * ) ( module_t * ), - int ( * ) ( module_t * ) ); +static void AllocateAllPlugins ( vlc_object_t * ); +static int AllocatePluginModule ( vlc_object_t *, char * ); #endif -static int DeleteModule ( module_t * ); -static int LockModule ( module_t * ); -static int UnlockModule ( module_t * ); +static int AllocateBuiltinModule( vlc_object_t *, + int ( * ) ( module_t * ), + int ( * ) ( module_t * ), + int ( * ) ( module_t * ) ); +static int DeleteModule ( module_t * ); +static int LockModule ( module_t * ); +static int UnlockModule ( module_t * ); #ifdef HAVE_DYNAMIC_PLUGINS -static int HideModule ( module_t * ); -static int CallSymbol ( module_t *, char * ); +static int HideModule ( module_t * ); +static int CallSymbol ( module_t *, char * ); #endif +#ifdef HAVE_DYNAMIC_PLUGINS static module_symbols_t symbols; +#endif /***************************************************************************** * module_InitBank: create the module bank. ***************************************************************************** - * This function creates a module bank structure and fills it with the - * built-in modules, as well as all the plugin modules it can find. + * This function creates a module bank structure which will be filled later + * on with all the modules found. *****************************************************************************/ -void module_InitBank( void ) +void __module_InitBank( vlc_object_t *p_this ) { -#ifdef HAVE_DYNAMIC_PLUGINS - static char * path[] = { ".", "lib", PLUGIN_PATH, NULL, NULL }; - - char ** ppsz_path = path; - char * psz_fullpath; - char * psz_file; -#if defined( SYS_BEOS ) || defined( SYS_DARWIN1_3 ) - char * psz_vlcpath = system_GetProgramPath(); - int i_vlclen = strlen( psz_vlcpath ); - boolean_t b_notinroot; -#endif - DIR * dir; - struct dirent * file; -#endif /* HAVE_DYNAMIC_PLUGINS */ - - p_module_bank->first = NULL; - vlc_mutex_init( &p_module_bank->lock ); + p_this->p_vlc->module_bank.first = NULL; + p_this->p_vlc->module_bank.i_count = 0; + vlc_mutex_init( p_this, &p_this->p_vlc->module_bank.lock ); /* * Store the symbols to be exported */ - STORE_SYMBOLS( &symbols ); - - /* - * Check all the built-in modules - */ -#ifdef ALLOCATE_ALL_BUILTINS - intf_WarnMsg( 2, "module: checking built-in modules" ); - - ALLOCATE_ALL_BUILTINS(); -#endif - - /* - * Check all the plugin modules we can find - */ #ifdef HAVE_DYNAMIC_PLUGINS - intf_WarnMsg( 2, "module: checking plugin modules" ); - - for( ; *ppsz_path != NULL ; ppsz_path++ ) - { - /* Store strlen(*ppsz_path) for later use. */ - int i_dirlen = strlen( *ppsz_path ); - -#if defined( SYS_BEOS ) || defined( SYS_DARWIN1_3 ) - b_notinroot = 0; - /* Under BeOS, we need to add beos_GetProgramPath() to access - * files under the current directory */ - if( ( i_dirlen > 1 ) && strncmp( *ppsz_path, "/", 1 ) ) - { - i_dirlen += i_vlclen + 2; - b_notinroot = 1; - - psz_fullpath = malloc( i_dirlen ); - if( psz_fullpath == NULL ) - { - continue; - } - sprintf( psz_fullpath, "%s/%s", psz_vlcpath, *ppsz_path ); - } - else -#endif - { - psz_fullpath = *ppsz_path; - } - - intf_WarnMsgImm( 1, "module: browsing `%s'", psz_fullpath ); - - if( (dir = opendir( psz_fullpath )) ) - { - /* Parse the directory and try to load all files it contains. */ - while( (file = readdir( dir )) ) - { - int i_filelen = strlen( file->d_name ); - - /* We only load files ending with ".so" */ - if( i_filelen > 3 - && !strncmp( file->d_name + i_filelen - 3, ".so", 3 ) ) - { - psz_file = malloc( i_dirlen + i_filelen + 2 ); - if( psz_file == NULL ) - { - continue; - } - sprintf( psz_file, "%s/%s", psz_fullpath, file->d_name ); - - /* We created a nice filename -- now we just try to load - * it as a plugin module. */ - AllocatePluginModule( psz_file ); - - /* We don't care if the allocation succeeded */ - free( psz_file ); - } - } - - /* Close the directory if successfully opened */ - closedir( dir ); - } - -#if defined( SYS_BEOS ) || defined( SYS_DARWIN1_3 ) - if( b_notinroot ) - { - free( psz_fullpath ); - } + STORE_SYMBOLS( &symbols ); #endif - } -#endif /* HAVE_DYNAMIC_PLUGINS */ - intf_WarnMsg( 3, "module: module bank initialized" ); + return; +} +/***************************************************************************** + * module_ResetBank: reset the module bank. + ***************************************************************************** + * This function resets the module bank by unloading all unused plugin + * modules. + *****************************************************************************/ +void __module_ResetBank( vlc_object_t *p_this ) +{ + msg_Err( p_this, "FIXME: module_ResetBank unimplemented" ); return; } @@ -237,41 +146,68 @@ void module_InitBank( void ) * This function unloads all unused plugin modules and empties the module * bank in case of success. *****************************************************************************/ -void module_EndBank( void ) +void __module_EndBank( vlc_object_t *p_this ) { module_t * p_next; - while( p_module_bank->first != NULL ) + while( p_this->p_vlc->module_bank.first != NULL ) { - if( DeleteModule( p_module_bank->first ) ) + if( DeleteModule( p_this->p_vlc->module_bank.first ) ) { /* Module deletion failed */ - intf_ErrMsg( "module error: `%s' can't be removed. trying harder.", - p_module_bank->first->psz_name ); + msg_Err( p_this, "`%s' can't be removed, trying harder", + p_this->p_vlc->module_bank.first->psz_object_name ); /* We just free the module by hand. Niahahahahaha. */ - p_next = p_module_bank->first->next; - free(p_module_bank->first); - p_module_bank->first = p_next; + p_next = p_this->p_vlc->module_bank.first->next; + free( p_this->p_vlc->module_bank.first ); + p_this->p_vlc->module_bank.first = p_next; } } /* Destroy the lock */ - vlc_mutex_destroy( &p_module_bank->lock ); + vlc_mutex_destroy( &p_this->p_vlc->module_bank.lock ); return; } /***************************************************************************** - * module_ResetBank: reset the module bank. + * module_LoadMain: load the main program info into the module bank. ***************************************************************************** - * This function resets the module bank by unloading all unused plugin - * modules. + * This function fills the module bank structure with the main module infos. + * This is very useful as it will allow us to consider the main program just + * as another module, and for instance the configuration options of main will + * be available in the module bank structure just as for every other module. *****************************************************************************/ -void module_ResetBank( void ) +void __module_LoadMain( vlc_object_t *p_this ) { - intf_ErrMsg( "FIXME: module_ResetBank unimplemented" ); - return; + AllocateBuiltinModule( p_this, InitModule__MODULE_main, + ActivateModule__MODULE_main, + DeactivateModule__MODULE_main ); +} + +/***************************************************************************** + * module_LoadBuiltins: load all modules which we built with. + ***************************************************************************** + * This function fills the module bank structure with the builtin modules. + *****************************************************************************/ +void __module_LoadBuiltins( vlc_object_t * p_this ) +{ + msg_Dbg( p_this, "checking builtin modules" ); + ALLOCATE_ALL_BUILTINS(); +} + +/***************************************************************************** + * module_LoadPlugins: load all plugin modules we can find. + ***************************************************************************** + * This function fills the module bank structure with the plugin modules. + *****************************************************************************/ +void __module_LoadPlugins( vlc_object_t * p_this ) +{ +#ifdef HAVE_DYNAMIC_PLUGINS + msg_Dbg( p_this, "checking plugin modules" ); + AllocateAllPlugins( p_this ); +#endif } /***************************************************************************** @@ -280,16 +216,16 @@ void module_ResetBank( void ) * This function parses the module bank and hides modules that have been * unused for a while. *****************************************************************************/ -void module_ManageBank( void ) +void __module_ManageBank( vlc_object_t *p_this ) { #ifdef HAVE_DYNAMIC_PLUGINS module_t * p_module; /* We take the global lock */ - vlc_mutex_lock( &p_module_bank->lock ); + vlc_mutex_lock( &p_this->p_vlc->module_bank.lock ); /* Parse the module list to see if any modules need to be unloaded */ - for( p_module = p_module_bank->first ; + for( p_module = p_this->p_vlc->module_bank.first ; p_module != NULL ; p_module = p_module->next ) { @@ -302,8 +238,8 @@ void module_ManageBank( void ) } else { - intf_WarnMsg( 1, "module: hiding unused plugin module `%s'", - p_module->psz_name ); + msg_Dbg( p_this, "hiding unused plugin module `%s'", + p_module->psz_object_name ); HideModule( p_module ); /* Break here, so that we only hide one module at a time */ @@ -313,7 +249,7 @@ void module_ManageBank( void ) } /* We release the global lock */ - vlc_mutex_unlock( &p_module_bank->lock ); + vlc_mutex_unlock( &p_this->p_vlc->module_bank.lock ); #endif /* HAVE_DYNAMIC_PLUGINS */ return; @@ -324,79 +260,314 @@ void module_ManageBank( void ) ***************************************************************************** * This function returns the module that best fits the asked capabilities. *****************************************************************************/ -module_t * module_Need( int i_capabilities, void *p_data ) +module_t * __module_Need( vlc_object_t *p_this, int i_capability, + const char *psz_name, void *p_data ) { - module_t * p_module; - module_t * p_bestmodule = NULL; - int i_score, i_totalscore, i_bestscore = 0; - int i_index; + typedef struct module_list_t module_list_t; + + struct module_list_t + { + module_t *p_module; + int i_score; + module_list_t *p_next; + }; + + module_list_t *p_list, *p_first, *p_tmp; + + int i_ret, i_index = 0; + vlc_bool_t b_intf = VLC_FALSE; + + module_t *p_module; + + int i_shortcuts = 0; + char *psz_shortcuts = NULL; + + msg_Dbg( p_this, "looking for %s module", + MODULE_CAPABILITY( i_capability ) ); /* We take the global lock */ - vlc_mutex_lock( &p_module_bank->lock ); + vlc_mutex_lock( &p_this->p_vlc->module_bank.lock ); + + /* Count how many different shortcuts were asked for */ + if( psz_name && *psz_name ) + { + char *psz_parser; + + i_shortcuts++; + psz_shortcuts = strdup( psz_name ); + + for( psz_parser = psz_shortcuts; *psz_parser; psz_parser++ ) + { + if( *psz_parser == ',' ) + { + *psz_parser = '\0'; + i_shortcuts++; + } + } + } + + /* Sort the modules and test them */ + p_list = malloc( p_this->p_vlc->module_bank.i_count + * sizeof( module_list_t ) ); + p_first = NULL; /* Parse the module list for capabilities and probe each of them */ - for( p_module = p_module_bank->first ; + for( p_module = p_this->p_vlc->module_bank.first ; p_module != NULL ; p_module = p_module->next ) { + int i_shortcut_bonus = 0; + /* Test that this module can do everything we need */ - if( ( p_module->i_capabilities & i_capabilities ) == i_capabilities ) + if( !(p_module->i_capabilities & ( 1 << i_capability )) ) + { + continue; + } + + /* Test if we have the required CPU */ + if( (p_module->i_cpu_capabilities + & p_this->p_vlc->i_cpu_capabilities) + != p_module->i_cpu_capabilities ) { - i_totalscore = 0; + continue; + } - LockModule( p_module ); + /* If we required a shortcut, check this plugin provides it. */ + if( i_shortcuts ) + { + vlc_bool_t b_trash = VLC_TRUE; + int i_dummy, i_short = i_shortcuts; + char *psz_name = psz_shortcuts; - /* Parse all the requested capabilities and test them */ - for( i_index = 0 ; (1 << i_index) <= i_capabilities ; i_index++ ) + while( i_short ) { - if( ( (1 << i_index) & i_capabilities ) ) + for( i_dummy = 0; + b_trash && p_module->pp_shortcuts[i_dummy]; + i_dummy++ ) { - i_score = ( (function_list_t *)p_module->p_functions) - [i_index].pf_probe( p_data ); + b_trash = strcmp( psz_name, + p_module->pp_shortcuts[i_dummy] ); + } - if( i_score ) - { - i_totalscore += i_score; - } - else - { - break; - } + if( !b_trash ) + { + i_shortcut_bonus = i_short * 10000; + break; + } + + while( *psz_name ) + { + psz_name++; } + psz_name++; + i_short--; } - /* If the high score was broken, we have a new champion */ - if( i_totalscore > i_bestscore ) + if( b_trash ) { - /* Keep the current module locked, but release the previous */ - if( p_bestmodule != NULL ) + continue; + } + } + /* If we didn't require a shortcut, trash zero-scored plugins */ + else if( !p_module->pi_score[i_capability] ) + { + continue; + } + + /* Special case: test if we requested a particular intf plugin */ + if( i_capability == MODULE_CAPABILITY_INTF ) + { + if( p_module->psz_program != NULL + && !strcmp( p_module->psz_program, + p_this->p_vlc->psz_object_name ) ) + { + if( !b_intf ) { - UnlockModule( p_bestmodule ); + /* Remove previous non-matching plugins */ + i_index = 0; + b_intf = VLC_TRUE; } + } + else + { + if( b_intf ) + { + /* This one doesn't match */ + continue; + } + } + } + + /* Store this new module */ + p_list[ i_index ].p_module = p_module; + p_list[ i_index ].i_score = p_module->pi_score[i_capability] + + i_shortcut_bonus; - /* This is the new best module */ - i_bestscore = i_totalscore; - p_bestmodule = p_module; + /* Add it to the modules-to-probe list */ + if( i_index == 0 ) + { + p_list[ 0 ].p_next = NULL; + p_first = p_list; + } + else + { + /* Ok, so at school you learned that quicksort is quick, and + * bubble sort sucks raw eggs. But that's when dealing with + * thousands of items. Here we have barely 50. */ + module_list_t *p_newlist = p_first; + + if( p_first->i_score < p_list[ i_index ].i_score ) + { + p_list[ i_index ].p_next = p_first; + p_first = &p_list[ i_index ]; } else { - /* This module wasn't interesting, unlock it and forget it */ - UnlockModule( p_module ); + while( p_newlist->p_next != NULL && + p_newlist->p_next->i_score >= p_list[ i_index ].i_score ) + { + p_newlist = p_newlist->p_next; + } + + p_list[ i_index ].p_next = p_newlist->p_next; + p_newlist->p_next = &p_list[ i_index ]; } } + + i_index++; + } + + /* Lock all selected modules */ + p_tmp = p_first; + while( p_tmp != NULL ) + { + LockModule( p_tmp->p_module ); + p_tmp = p_tmp->p_next; } - /* We can release the global lock, module refcount was incremented */ - vlc_mutex_unlock( &p_module_bank->lock ); + /* We can release the global lock, module refcounts were incremented */ + vlc_mutex_unlock( &p_this->p_vlc->module_bank.lock ); + + /* Parse the linked list and use the first successful module */ + p_tmp = p_first; + while( p_tmp != NULL ) + { + /* Test the requested capability */ + switch( i_capability ) + { + case MODULE_CAPABILITY_ACCESS: + i_ret = p_tmp->p_module->p_functions->access.functions. + access.pf_open( (input_thread_t *)p_data ); + break; + + case MODULE_CAPABILITY_DEMUX: + i_ret = p_tmp->p_module->p_functions->demux.functions. + demux.pf_init( (input_thread_t *)p_data ); + break; + + case MODULE_CAPABILITY_NETWORK: + i_ret = p_tmp->p_module->p_functions->network.functions. + network.pf_open( p_this, (network_socket_t *)p_data ); + break; + + case MODULE_CAPABILITY_DECODER: + i_ret = p_tmp->p_module->p_functions->dec.functions. + dec.pf_probe( (u8 *)p_data ); + break; + + case MODULE_CAPABILITY_INTF: + i_ret = p_tmp->p_module->p_functions->intf.functions. + intf.pf_open( (intf_thread_t *)p_data ); + break; + + case MODULE_CAPABILITY_AOUT: + i_ret = p_tmp->p_module->p_functions->aout.functions. + aout.pf_open( (aout_thread_t *)p_data ); + break; + + case MODULE_CAPABILITY_VOUT: + case MODULE_CAPABILITY_VOUT_FILTER: + i_ret = p_tmp->p_module->p_functions->vout.functions. + vout.pf_create( (vout_thread_t *)p_data ); + break; + + case MODULE_CAPABILITY_CHROMA: + i_ret = p_tmp->p_module->p_functions->chroma.functions. + chroma.pf_init( (vout_thread_t *)p_data ); + break; + + case MODULE_CAPABILITY_IDCT: + case MODULE_CAPABILITY_IMDCT: + case MODULE_CAPABILITY_MOTION: + case MODULE_CAPABILITY_DOWNMIX: + case MODULE_CAPABILITY_MEMCPY: + /* This one always works */ + i_ret = 0; + break; + + default: + msg_Err( p_this, "unknown module type %i", i_capability ); + i_ret = -1; + break; + } + + /* If the high score was broken, we have a new champion */ + if( i_ret == 0 ) + { + break; + } + else + { + UnlockModule( p_tmp->p_module ); + } + + p_tmp = p_tmp->p_next; + } + + /* Store the locked module value */ + if( p_tmp != NULL ) + { + p_module = p_tmp->p_module; + p_tmp = p_tmp->p_next; + } + else + { + p_module = NULL; + } + + /* Unlock the remaining modules */ + while( p_tmp != NULL ) + { + UnlockModule( p_tmp->p_module ); + p_tmp = p_tmp->p_next; + } + + free( p_list ); + + if( p_module != NULL ) + { + msg_Info( p_module, "found and locked %s module `%s'", + MODULE_CAPABILITY( i_capability ), + p_module->psz_object_name ); + } + else if( p_first == NULL ) + { + msg_Err( p_this, "no available %s module matched `%s'", + MODULE_CAPABILITY( i_capability ), psz_name ); + } + else if( psz_name != NULL && *psz_name ) + { + msg_Err( p_this, "could not load any %s module matching `%s'", + MODULE_CAPABILITY( i_capability ), psz_name ); + } - if( p_bestmodule != NULL ) + if( psz_shortcuts ) { - intf_WarnMsg( 1, "module: locking module `%s'", - p_bestmodule->psz_name ); + free( psz_shortcuts ); } - /* Don't forget that the module is still locked if bestmodule != NULL */ - return( p_bestmodule ); + /* Don't forget that the module is still locked */ + return p_module; } /***************************************************************************** @@ -408,16 +579,16 @@ module_t * module_Need( int i_capabilities, void *p_data ) void module_Unneed( module_t * p_module ) { /* We take the global lock */ - vlc_mutex_lock( &p_module_bank->lock ); + vlc_mutex_lock( &p_module->p_vlc->module_bank.lock ); /* Just unlock the module - we can't do anything if it fails, * so there is no need to check the return value. */ UnlockModule( p_module ); - intf_WarnMsg( 1, "module: unlocking module `%s'", p_module->psz_name ); + msg_Info( p_module, "unlocking module `%s'", p_module->psz_object_name ); /* We release the global lock */ - vlc_mutex_unlock( &p_module_bank->lock ); + vlc_mutex_unlock( &p_module->p_vlc->module_bank.lock ); return; } @@ -426,7 +597,99 @@ void module_Unneed( module_t * p_module ) * Following functions are local. *****************************************************************************/ +/***************************************************************************** + * AllocateAllPlugins: load all plugin modules we can find. + *****************************************************************************/ #ifdef HAVE_DYNAMIC_PLUGINS +static void AllocateAllPlugins( vlc_object_t *p_this ) +{ + /* Yes, there are two NULLs because we replace one with "plugin-path". */ + char * path[] = { "plugins", PLUGIN_PATH, NULL, NULL }; + + char ** ppsz_path = path; + char * psz_fullpath; + char * psz_file; +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) + char * psz_vlcpath = system_GetProgramPath(); + int i_vlclen = strlen( psz_vlcpath ); + vlc_bool_t b_notinroot; +#endif + DIR * dir; + struct dirent * file; + + /* If the user provided a plugin path, we add it to the list */ + path[ sizeof(path)/sizeof(char*) - 2 ] = config_GetPsz( p_this, + "plugin-path" ); + + for( ; *ppsz_path != NULL ; ppsz_path++ ) + { + /* Store strlen(*ppsz_path) for later use. */ + int i_dirlen = strlen( *ppsz_path ); + +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) + b_notinroot = VLC_FALSE; + /* Under BeOS, we need to add beos_GetProgramPath() to access + * files under the current directory */ + if( ( i_dirlen > 1 ) && strncmp( *ppsz_path, "/", 1 ) ) + { + i_dirlen += i_vlclen + 2; + b_notinroot = VLC_TRUE; + + psz_fullpath = malloc( i_dirlen ); + if( psz_fullpath == NULL ) + { + continue; + } + sprintf( psz_fullpath, "%s/%s", psz_vlcpath, *ppsz_path ); + } + else +#endif + { + psz_fullpath = *ppsz_path; + } + + msg_Dbg( p_this, "browsing `%s'", psz_fullpath ); + + if( (dir = opendir( psz_fullpath )) ) + { + /* Parse the directory and try to load all files it contains. */ + while( (file = readdir( dir )) ) + { + int i_filelen = strlen( file->d_name ); + + /* We only load files ending with ".so" */ + if( i_filelen > 3 + && !strncmp( file->d_name + i_filelen - 3, ".so", 3 ) ) + { + psz_file = malloc( i_dirlen + i_filelen + 2 ); + if( psz_file == NULL ) + { + continue; + } + sprintf( psz_file, "%s/%s", psz_fullpath, file->d_name ); + + /* We created a nice filename -- now we just try to load + * it as a plugin module. */ + AllocatePluginModule( p_this, psz_file ); + + /* We don't care if the allocation succeeded */ + free( psz_file ); + } + } + + /* Close the directory if successfully opened */ + closedir( dir ); + } + +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) + if( b_notinroot ) + { + free( psz_fullpath ); + } +#endif + } +} + /***************************************************************************** * AllocatePluginModule: load a module into memory and initialize it. ***************************************************************************** @@ -434,28 +697,31 @@ void module_Unneed( module_t * p_module ) * for its information data. The module can then be handled by module_Need, * module_Unneed and HideModule. It can be removed by DeleteModule. *****************************************************************************/ -static int AllocatePluginModule( char * psz_filename ) +static int AllocatePluginModule( vlc_object_t * p_this, char * psz_filename ) { + char **pp_shortcut; module_t * p_module, * p_othermodule; module_handle_t handle; /* Try to dynamically load the module. */ if( module_load( psz_filename, &handle ) ) { + char psz_buffer[256]; + /* The plugin module couldn't be opened */ - intf_WarnMsgImm( 1, "module warning: cannot open %s (%s)", - psz_filename, module_error() ); - return( -1 ); + msg_Warn( p_this, "cannot open %s (%s)", + psz_filename, module_error( psz_buffer ) ); + return -1; } /* Now that we have successfully loaded the module, we can * allocate a structure for it */ - p_module = malloc( sizeof( module_t ) ); + p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE ); if( p_module == NULL ) { - intf_ErrMsg( "module error: can't allocate p_module" ); + msg_Err( p_this, "out of memory" ); module_unload( handle ); - return( -1 ); + return -1; } /* We need to fill these since they may be needed by CallSymbol() */ @@ -463,116 +729,111 @@ static int AllocatePluginModule( char * psz_filename ) p_module->is.plugin.handle = handle; p_module->p_symbols = &symbols; - /* Initialize the module : fill p_module->psz_name, etc. */ - if( CallSymbol( p_module, "InitModule" ) != 0 ) + /* Initialize the module: fill p_module->psz_object_name, default config */ + if( CallSymbol( p_module, "InitModule" MODULE_SUFFIX ) != 0 ) { /* We couldn't call InitModule() */ - free( p_module ); + vlc_object_destroy( p_module ); module_unload( handle ); - return( -1 ); - } - - /* Check that version numbers match */ - if( strcmp( VERSION, p_module->psz_version ) ) - { - free( p_module ); - module_unload( handle ); - return( -1 ); + return -1; } /* Check that we don't already have a module with this name */ - for( p_othermodule = p_module_bank->first ; + for( p_othermodule = p_this->p_vlc->module_bank.first ; p_othermodule != NULL ; p_othermodule = p_othermodule->next ) { - if( !strcmp( p_othermodule->psz_name, p_module->psz_name ) ) + if( !strcmp( p_othermodule->psz_object_name, + p_module->psz_object_name ) ) { - free( p_module ); + msg_Warn( p_this, + "cannot load %s, a module named `%s' already exists", + psz_filename, p_module->psz_object_name ); + config_Free( p_module ); + vlc_object_destroy( p_module ); module_unload( handle ); - return( -1 ); + return -1; } } /* Activate the module : fill the capability structure, etc. */ - if( CallSymbol( p_module, "ActivateModule" ) != 0 ) + if( CallSymbol( p_module, "ActivateModule" MODULE_SUFFIX ) != 0 ) { /* We couldn't call ActivateModule() */ - free( p_module ); + config_Free( p_module ); + vlc_object_destroy( p_module ); module_unload( handle ); - return( -1 ); + return -1; + } + + for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) + { + *pp_shortcut = strdup( *pp_shortcut ); } /* We strdup() these entries so that they are still valid when the * module is unloaded. */ p_module->is.plugin.psz_filename = strdup( p_module->is.plugin.psz_filename ); - p_module->psz_name = strdup( p_module->psz_name ); + p_module->psz_object_name = strdup( p_module->psz_object_name ); p_module->psz_longname = strdup( p_module->psz_longname ); - p_module->psz_version = strdup( p_module->psz_version ); + if( p_module->is.plugin.psz_filename == NULL - || p_module->psz_name == NULL - || p_module->psz_longname == NULL - || p_module->psz_version == NULL ) + || p_module->psz_object_name == NULL + || p_module->psz_longname == NULL ) { - intf_ErrMsg( "module error: can't duplicate strings" ); - - if( p_module->is.plugin.psz_filename != NULL ) - { - free( p_module->is.plugin.psz_filename ); - } + msg_Err( p_this, "out of memory" ); - if( p_module->psz_name != NULL ) - { - free( p_module->psz_name ); - } - - if( p_module->psz_longname != NULL ) - { - free( p_module->psz_longname ); - } - - if( p_module->psz_version != NULL ) - { - free( p_module->psz_version ); - } + free( p_module->is.plugin.psz_filename ); + free( p_module->psz_object_name ); + free( p_module->psz_longname ); + free( p_module->psz_program ); - free( p_module ); + config_Free( p_module ); + vlc_object_destroy( p_module ); module_unload( handle ); - return( -1 ); + return -1; + } + + if( p_module->psz_program != NULL ) + { + p_module->psz_program = strdup( p_module->psz_program ); } /* Everything worked fine ! The module is ready to be added to the list. */ p_module->i_usage = 0; p_module->i_unused_delay = 0; - p_module->b_builtin = 0; + p_module->b_builtin = VLC_FALSE; /* Link module into the linked list */ - if( p_module_bank->first != NULL ) + if( p_this->p_vlc->module_bank.first != NULL ) { - p_module_bank->first->prev = p_module; + p_this->p_vlc->module_bank.first->prev = p_module; } - p_module->next = p_module_bank->first; + p_module->next = p_this->p_vlc->module_bank.first; p_module->prev = NULL; - p_module_bank->first = p_module; + p_this->p_vlc->module_bank.first = p_module; + p_this->p_vlc->module_bank.i_count++; - /* Immediate message so that a slow module doesn't make the user wait */ - intf_WarnMsgImm( 2, "module: plugin module `%s', %s", - p_module->psz_name, p_module->psz_longname ); + msg_Dbg( p_this, "plugin `%s', %s", + p_module->psz_object_name, p_module->psz_longname ); - return( 0 ); + vlc_object_attach( p_module, p_this ); + + return 0; } #endif /* HAVE_DYNAMIC_PLUGINS */ -#ifdef ALLOCATE_ALL_BUILTINS /***************************************************************************** - * AllocateBuiltinModule: initialize a built-in module. + * AllocateBuiltinModule: initialize a builtin module. ***************************************************************************** - * This function registers a built-in module and allocates a structure + * This function registers a builtin module and allocates a structure * for its information data. The module can then be handled by module_Need, * module_Unneed and HideModule. It can be removed by DeleteModule. *****************************************************************************/ -static int AllocateBuiltinModule( int ( *pf_init ) ( module_t * ), +static int AllocateBuiltinModule( vlc_object_t * p_this, + int ( *pf_init ) ( module_t * ), int ( *pf_activate ) ( module_t * ), int ( *pf_deactivate ) ( module_t * ) ) { @@ -580,39 +841,37 @@ static int AllocateBuiltinModule( int ( *pf_init ) ( module_t * ), /* Now that we have successfully loaded the module, we can * allocate a structure for it */ - p_module = malloc( sizeof( module_t ) ); + p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE ); if( p_module == NULL ) { - intf_ErrMsg( "module error: can't allocate p_module" ); - return( -1 ); + msg_Err( p_this, "out of memory" ); + return -1; } - /* Initialize the module : fill p_module->psz_name, etc. */ + /* Initialize the module : fill p_module->psz_object_name, etc. */ if( pf_init( p_module ) != 0 ) { /* With a well-written module we shouldn't have to print an * additional error message here, but just make sure. */ - intf_ErrMsg( "module error: failed calling init in builtin module" ); - free( p_module ); - return( -1 ); - } - - /* Check that version numbers match */ - if( strcmp( VERSION, p_module->psz_version ) ) - { - free( p_module ); - return( -1 ); + msg_Err( p_this, "failed calling init in builtin module" ); + vlc_object_destroy( p_module ); + return -1; } /* Check that we don't already have a module with this name */ - for( p_othermodule = p_module_bank->first ; + for( p_othermodule = p_this->p_vlc->module_bank.first ; p_othermodule != NULL ; p_othermodule = p_othermodule->next ) { - if( !strcmp( p_othermodule->psz_name, p_module->psz_name ) ) + if( !strcmp( p_othermodule->psz_object_name, + p_module->psz_object_name ) ) { - free( p_module ); - return( -1 ); + msg_Warn( p_this, "cannot load builtin `%s', " + "a module named `%s' already exists", + p_module->psz_object_name, p_module->psz_object_name ); + config_Free( p_module ); + vlc_object_destroy( p_module ); + return -1; } } @@ -620,65 +879,36 @@ static int AllocateBuiltinModule( int ( *pf_init ) ( module_t * ), { /* With a well-written module we shouldn't have to print an * additional error message here, but just make sure. */ - intf_ErrMsg( "module error: failed calling activate " - "in builtin module" ); - free( p_module ); - return( -1 ); - } - - /* We strdup() these entries so that they are still valid when the - * module is unloaded. */ - p_module->psz_name = strdup( p_module->psz_name ); - p_module->psz_longname = strdup( p_module->psz_longname ); - p_module->psz_version = strdup( p_module->psz_version ); - if( p_module->psz_name == NULL - || p_module->psz_longname == NULL - || p_module->psz_version == NULL ) - { - intf_ErrMsg( "module error: can't duplicate strings" ); - - if( p_module->psz_name != NULL ) - { - free( p_module->psz_name ); - } - - if( p_module->psz_longname != NULL ) - { - free( p_module->psz_longname ); - } - - if( p_module->psz_version != NULL ) - { - free( p_module->psz_version ); - } - - free( p_module ); - return( -1 ); + msg_Err( p_this, "failed calling activate in builtin module" ); + config_Free( p_module ); + vlc_object_destroy( p_module ); + return -1; } /* Everything worked fine ! The module is ready to be added to the list. */ p_module->i_usage = 0; p_module->i_unused_delay = 0; - p_module->b_builtin = 1; + p_module->b_builtin = VLC_TRUE; p_module->is.builtin.pf_deactivate = pf_deactivate; /* Link module into the linked list */ - if( p_module_bank->first != NULL ) + if( p_this->p_vlc->module_bank.first != NULL ) { - p_module_bank->first->prev = p_module; + p_this->p_vlc->module_bank.first->prev = p_module; } - p_module->next = p_module_bank->first; + p_module->next = p_this->p_vlc->module_bank.first; p_module->prev = NULL; - p_module_bank->first = p_module; + p_this->p_vlc->module_bank.first = p_module; + p_this->p_vlc->module_bank.i_count++; + + msg_Dbg( p_this, "builtin `%s', %s", + p_module->psz_object_name, p_module->psz_longname ); - /* Immediate message so that a slow module doesn't make the user wait */ - intf_WarnMsgImm( 2, "module: builtin module `%s', %s", - p_module->psz_name, p_module->psz_longname ); + vlc_object_attach( p_module, p_this ); - return( 0 ); + return 0; } -#endif /* ALLOCATE_ALL_BUILTINS */ /***************************************************************************** * DeleteModule: delete a module and its structure. @@ -694,9 +924,9 @@ static int DeleteModule( module_t * p_module ) { if( p_module->i_usage != 0 ) { - intf_ErrMsg( "module error: trying to free builtin module `%s' with" - " usage %i", p_module->psz_name, p_module->i_usage ); - return( -1 ); + msg_Err( p_module, "trying to free builtin module `%s' with " + "usage %i", p_module->psz_object_name, p_module->i_usage ); + return -1; } else { @@ -709,9 +939,9 @@ static int DeleteModule( module_t * p_module ) { if( p_module->i_usage >= 1 ) { - intf_ErrMsg( "module error: trying to free module `%s' which is" - " still in use", p_module->psz_name ); - return( -1 ); + msg_Err( p_module, "trying to free module `%s' which is " + "still in use", p_module->psz_object_name ); + return -1; } /* Two possibilities here: i_usage == -1 and the module is already @@ -721,42 +951,53 @@ static int DeleteModule( module_t * p_module ) { if( HideModule( p_module ) != 0 ) { - return( -1 ); + return -1; } } } #endif - /* Unlink the module from the linked list. */ - if( p_module == p_module_bank->first ) - { - p_module_bank->first = p_module->next; - } + vlc_object_detach_all( p_module ); + /* Unlink the module from the linked list. */ if( p_module->prev != NULL ) { p_module->prev->next = p_module->next; } + else + { + p_module->p_vlc->module_bank.first = p_module->next; + } if( p_module->next != NULL ) { p_module->next->prev = p_module->prev; } + p_module->p_vlc->module_bank.i_count--; + /* We free the structures that we strdup()ed in Allocate*Module(). */ #ifdef HAVE_DYNAMIC_PLUGINS if( !p_module->b_builtin ) { + char **pp_shortcut = p_module->pp_shortcuts; + + for( ; *pp_shortcut ; pp_shortcut++ ) + { + free( *pp_shortcut ); + } + free( p_module->is.plugin.psz_filename ); + free( p_module->psz_object_name ); + free( p_module->psz_longname ); + free( p_module->psz_program ); } #endif - free( p_module->psz_name ); - free( p_module->psz_longname ); - free( p_module->psz_version ); - free( p_module ); + config_Free( p_module ); + vlc_object_destroy( p_module ); - return( 0 ); + return 0; } /***************************************************************************** @@ -774,34 +1015,36 @@ static int LockModule( module_t * p_module ) { /* This module is already loaded and activated, we can return */ p_module->i_usage++; - return( 0 ); + return 0; } if( p_module->b_builtin ) { - /* A built-in module should always have a refcount >= 0 ! */ - intf_ErrMsg( "module error: built-in module `%s' has refcount %i", - p_module->psz_name, p_module->i_usage ); - return( -1 ); + /* A builtin module should always have a refcount >= 0 ! */ + msg_Err( p_module, "builtin module `%s' has refcount %i", + p_module->psz_object_name, p_module->i_usage ); + return -1; } #ifdef HAVE_DYNAMIC_PLUGINS if( p_module->i_usage != -1 ) { /* This shouldn't happen. Ever. We have serious problems here. */ - intf_ErrMsg( "module error: plugin module `%s' has refcount %i", - p_module->psz_name, p_module->i_usage ); - return( -1 ); + msg_Err( p_module, "plugin module `%s' has refcount %i", + p_module->psz_object_name, p_module->i_usage ); + return -1; } /* i_usage == -1, which means that the module isn't in memory */ if( module_load( p_module->is.plugin.psz_filename, &p_module->is.plugin.handle ) ) { + char psz_buffer[256]; + /* The plugin module couldn't be opened */ - intf_ErrMsg( "module error: cannot open %s (%s)", - p_module->is.plugin.psz_filename, module_error() ); - return( -1 ); + msg_Err( p_module, "cannot open %s (%s)", + p_module->is.plugin.psz_filename, module_error(psz_buffer) ); + return -1; } /* FIXME: what to do if the guy modified the plugin while it was @@ -809,20 +1052,20 @@ static int LockModule( module_t * p_module ) * to be a bit more clever here. */ /* Activate the module : fill the capability structure, etc. */ - if( CallSymbol( p_module, "ActivateModule" ) != 0 ) + if( CallSymbol( p_module, "ActivateModule" MODULE_SUFFIX ) != 0 ) { /* We couldn't call ActivateModule() -- looks nasty, but * we can't do much about it. Just try to unload module. */ module_unload( p_module->is.plugin.handle ); p_module->i_usage = -1; - return( -1 ); + return -1; } /* Everything worked fine ! The module is ready to be used */ p_module->i_usage = 1; #endif /* HAVE_DYNAMIC_PLUGINS */ - return( 0 ); + return 0; } /***************************************************************************** @@ -836,16 +1079,16 @@ static int UnlockModule( module_t * p_module ) if( p_module->i_usage <= 0 ) { /* This shouldn't happen. Ever. We have serious problems here. */ - intf_ErrMsg( "module error: trying to call module_Unneed() on `%s'" - " which isn't even in use", p_module->psz_name ); - return( -1 ); + msg_Err( p_module, "trying to call module_Unneed() on `%s' " + "which is not in use", p_module->psz_object_name ); + return -1; } /* This module is still in use, we can return */ p_module->i_usage--; p_module->i_unused_delay = 0; - return( 0 ); + return 0; } #ifdef HAVE_DYNAMIC_PLUGINS @@ -860,41 +1103,41 @@ static int HideModule( module_t * p_module ) { if( p_module->b_builtin ) { - /* A built-in module should never be hidden. */ - intf_ErrMsg( "module error: trying to hide built-in module `%s'", - p_module->psz_name ); - return( -1 ); + /* A builtin module should never be hidden. */ + msg_Err( p_module, "trying to hide builtin module `%s'", + p_module->psz_object_name ); + return -1; } if( p_module->i_usage >= 1 ) { - intf_ErrMsg( "module error: trying to hide module `%s' which is still" - " in use", p_module->psz_name ); - return( -1 ); + msg_Err( p_module, "trying to hide module `%s' which is still " + "in use", p_module->psz_object_name ); + return -1; } if( p_module->i_usage <= -1 ) { - intf_ErrMsg( "module error: trying to hide module `%s' which is already" - " hidden", p_module->psz_name ); - return( -1 ); + msg_Err( p_module, "trying to hide module `%s' which is already " + "hidden", p_module->psz_object_name ); + return -1; } /* Deactivate the module : free the capability structure, etc. */ - if( CallSymbol( p_module, "DeactivateModule" ) != 0 ) + if( CallSymbol( p_module, "DeactivateModule" MODULE_SUFFIX ) != 0 ) { /* We couldn't call DeactivateModule() -- looks nasty, but * we can't do much about it. Just try to unload module anyway. */ module_unload( p_module->is.plugin.handle ); p_module->i_usage = -1; - return( -1 ); + return -1; } /* Everything worked fine, we can safely unload the module. */ module_unload( p_module->is.plugin.handle ); p_module->i_usage = -1; - return( 0 ); + return 0; } /***************************************************************************** @@ -913,12 +1156,13 @@ static int CallSymbol( module_t * p_module, char * psz_name ) if( pf_symbol == NULL ) { + char psz_buffer[256]; + /* We couldn't load the symbol */ - intf_WarnMsg( 1, "module warning: " - "cannot find symbol %s in module %s (%s)", - psz_name, p_module->is.plugin.psz_filename, - module_error() ); - return( -1 ); + msg_Warn( p_module, "cannot find symbol %s in module %s (%s)", + psz_name, p_module->is.plugin.psz_filename, + module_error( psz_buffer ) ); + return -1; } /* We can now try to call the symbol */ @@ -926,13 +1170,13 @@ static int CallSymbol( module_t * p_module, char * psz_name ) { /* With a well-written module we shouldn't have to print an * additional error message here, but just make sure. */ - intf_ErrMsg( "module error: failed calling symbol %s in module %s", - psz_name, p_module->is.plugin.psz_filename ); - return( -1 ); + msg_Err( p_module, "failed calling symbol %s in module %s", + psz_name, p_module->is.plugin.psz_filename ); + return -1; } /* Everything worked fine, we can return */ - return( 0 ); + return 0; } #endif /* HAVE_DYNAMIC_PLUGINS */