X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmodules%2Fmodules.c;h=ee036e31310f3a303803555188c4316d1a48c626;hb=b4f8c0f6a4b158e5dc824734ee23ce47a3f07ec2;hp=ceefde8a6b27a50735a4f541bb3f04fbb9940f4d;hpb=cc4cca2fd565125ad3260c934df9c88892e375f2;p=vlc diff --git a/src/modules/modules.c b/src/modules/modules.c index ceefde8a6b..ee036e3131 100644 --- a/src/modules/modules.c +++ b/src/modules/modules.c @@ -24,7 +24,12 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include #include "libvlc.h" /* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS @@ -36,6 +41,7 @@ #include /* free(), strtol() */ #include /* sprintf() */ #include /* strdup() */ +#include #ifdef HAVE_DIRENT_H # include @@ -76,13 +82,16 @@ # endif #endif -#include "config/config.h" +#include "config/configuration.h" #include "vlc_charset.h" +#include "vlc_arrays.h" #include "modules/modules.h" #include "modules/builtin.h" +module_bank_t *p_module_bank; + /***************************************************************************** * Local prototypes *****************************************************************************/ @@ -93,98 +102,88 @@ static int AllocatePluginFile ( vlc_object_t *, char *, int64_t, int64_t ); static module_t * AllocatePlugin( vlc_object_t *, char * ); #endif static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) ); -static int DeleteModule ( module_t *, vlc_bool_t ); +static void DeleteModule ( module_t * ); #ifdef HAVE_DYNAMIC_PLUGINS static void DupModule ( module_t * ); static void UndupModule ( module_t * ); #endif -static void module_LoadMain( vlc_object_t *p_this ); - -/***************************************************************************** - * module_InitBank: create the module bank. - ***************************************************************************** - * This function creates a module bank structure which will be filled later +/** + * Init bank + * + * Creates a module bank structure which will be filled later * on with all the modules found. - *****************************************************************************/ + * \param p_this vlc object structure + * \return nothing + */ void __module_InitBank( vlc_object_t *p_this ) { module_bank_t *p_bank = NULL; - vlc_value_t lockval; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( p_libvlc_global->p_module_bank ) + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); + + if( p_module_bank == NULL ) { - p_libvlc_global->p_module_bank->i_usage++; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - return; + p_bank = calloc (1, sizeof(*p_bank)); + p_bank->i_usage = 1; + p_bank->i_cache = p_bank->i_loaded_cache = 0; + p_bank->pp_cache = p_bank->pp_loaded_cache = NULL; + p_bank->b_cache = p_bank->b_cache_dirty = + p_bank->b_cache_delete = false; + p_bank->head = NULL; + + /* Everything worked, attach the object */ + p_module_bank = p_bank; + + /* Fills the module bank structure with the main module infos. + * This is very useful as it will allow us to consider the main + * library 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. */ + AllocateBuiltinModule( p_this, vlc_entry__main ); } - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + else + p_module_bank->i_usage++; - p_bank = vlc_object_create( p_this, sizeof(module_bank_t) ); - if( !p_bank ) - return; - p_bank->psz_object_name = "module bank"; - p_bank->i_usage = 1; - p_bank->i_cache = p_bank->i_loaded_cache = 0; - p_bank->pp_cache = p_bank->pp_loaded_cache = NULL; - p_bank->b_cache = p_bank->b_cache_dirty = - p_bank->b_cache_delete = VLC_FALSE; - - /* Everything worked, attach the object */ - p_libvlc_global->p_module_bank = p_bank; - vlc_object_attach( p_bank, p_libvlc_global ); - - module_LoadMain( p_this ); + vlc_mutex_unlock( lock ); } -/***************************************************************************** - * module_EndBank: empty the module bank. - ***************************************************************************** - * This function unloads all unused plugin modules and empties the module +/** + * End bank + * + * Unloads all unused plugin modules and empties the module * bank in case of success. - *****************************************************************************/ + * \param p_this vlc object structure + * \return nothing + */ void __module_EndBank( vlc_object_t *p_this ) { - module_t * p_next = NULL; - vlc_value_t lockval; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( !p_libvlc_global->p_module_bank ) - { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - return; - } - if( --p_libvlc_global->p_module_bank->i_usage ) + module_bank_t *p_bank; + + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); + p_bank = p_module_bank; + assert (p_bank != NULL); + if( --p_bank->i_usage > 0 ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + /*FIXME: For thread safety, we need to: + p_module_bank = NULL; - immediately, but that will crash the cache */ + vlc_mutex_unlock( lock ); + /* Save the configuration */ config_AutoSaveConfigFile( p_this ); #ifdef HAVE_DYNAMIC_PLUGINS -# define p_bank p_libvlc_global->p_module_bank if( p_bank->b_cache ) CacheSave( p_this ); while( p_bank->i_loaded_cache-- ) { if( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] ) { - DeleteModule( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module, - p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->b_used ); + DeleteModule( + p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module ); free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->psz_file ); free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] ); p_bank->pp_loaded_cache[p_bank->i_loaded_cache] = NULL; @@ -206,193 +205,225 @@ void __module_EndBank( vlc_object_t *p_this ) free( p_bank->pp_cache ); p_bank->pp_cache = NULL; } -# undef p_bank #endif - vlc_object_detach( p_libvlc_global->p_module_bank ); - - while( p_libvlc_global->p_module_bank->i_children ) - { - p_next = (module_t *)p_libvlc_global->p_module_bank->pp_children[0]; - - if( DeleteModule( p_next, VLC_TRUE ) ) - { - /* Module deletion failed */ - msg_Err( p_this, "module \"%s\" can't be removed, trying harder", - p_next->psz_object_name ); - - /* We just free the module by hand. Niahahahahaha. */ - vlc_object_detach( p_next ); - vlc_object_destroy( p_next ); - } - } - - vlc_object_destroy( p_libvlc_global->p_module_bank ); - p_libvlc_global->p_module_bank = NULL; -} - -/***************************************************************************** - * module_LoadMain: load the main program info into the module bank. - ***************************************************************************** - * 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. - *****************************************************************************/ -static void module_LoadMain( vlc_object_t *p_this ) -{ - vlc_value_t lockval; - libvlc_global_data_t *p_libvlc_global = vlc_global(); + while( p_bank->head != NULL ) + DeleteModule( p_bank->head ); - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( p_libvlc_global->p_module_bank->b_main ) - { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - return; - } - p_libvlc_global->p_module_bank->b_main = VLC_TRUE; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - - AllocateBuiltinModule( p_this, vlc_entry__main ); + p_module_bank = NULL; /* FIXME: do this inside the lock */ + free( p_bank ); } -/***************************************************************************** - * module_LoadBuiltins: load all modules which we built with. - ***************************************************************************** - * This function fills the module bank structure with the builtin modules. - *****************************************************************************/ +/** + * Load all modules which we built with. + * + * Fills the module bank structure with the builtin modules. + * \param p_this vlc object structure + * \return nothing + */ void __module_LoadBuiltins( vlc_object_t * p_this ) { - vlc_value_t lockval; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( p_libvlc_global->p_module_bank->b_builtins ) + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); + if( p_module_bank->b_builtins ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } - p_libvlc_global->p_module_bank->b_builtins = VLC_TRUE; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + p_module_bank->b_builtins = true; + vlc_mutex_unlock( lock ); 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. - *****************************************************************************/ +/** + * Load all plugins + * + * Load all plugin modules we can find. + * Fills the module bank structure with the plugin modules. + * \param p_this vlc object structure + * \return nothing + */ void __module_LoadPlugins( vlc_object_t * p_this ) { #ifdef HAVE_DYNAMIC_PLUGINS - vlc_value_t lockval; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( p_libvlc_global->p_module_bank->b_plugins ) + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); + if( p_module_bank->b_plugins ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } - p_libvlc_global->p_module_bank->b_plugins = VLC_TRUE; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + p_module_bank->b_plugins = true; + vlc_mutex_unlock( lock ); msg_Dbg( p_this, "checking plugin modules" ); if( config_GetInt( p_this, "plugins-cache" ) ) - p_libvlc_global->p_module_bank->b_cache = VLC_TRUE; + p_module_bank->b_cache = true; - if( p_libvlc_global->p_module_bank->b_cache || - p_libvlc_global->p_module_bank->b_cache_delete ) CacheLoad( p_this ); + if( p_module_bank->b_cache || + p_module_bank->b_cache_delete ) CacheLoad( p_this ); AllocateAllPlugins( p_this ); #endif } -/***************************************************************************** - * module_IsCapable: checks whether a module implements a capability. - *****************************************************************************/ -vlc_bool_t module_IsCapable( const module_t *m, const char *cap ) +/** + * Checks whether a module implements a capability. + * + * \param m the module + * \param cap the capability to check + * \return TRUE if the module have the capability + */ +bool module_provides( const module_t *m, const char *cap ) { return !strcmp( m->psz_capability, cap ); } -/***************************************************************************** - * module_GetObjName: internal name of a module. - *****************************************************************************/ -const char *module_GetObjName( const module_t *m ) +/** + * Get the internal name of a module + * + * \param m the module + * \return the module name + */ +const char *module_get_object( const module_t *m ) { return m->psz_object_name; } -/***************************************************************************** - * module_GetName: human-friendly name of a module. - *****************************************************************************/ -const char *module_GetName( const module_t *m, vlc_bool_t long_name ) +/** + * Get the human-friendly name of a module. + * + * \param m the module + * \param long_name TRUE to have the long name of the module + * \return the short or long name of the module + */ +const char *module_get_name( const module_t *m, bool long_name ) { if( long_name && ( m->psz_longname != NULL) ) return m->psz_longname; - + return m->psz_shortname ?: m->psz_object_name; } -const char *module_GetHelp( const module_t *m ) +/** + * Get the help for a module + * + * \param m the module + * \return the help + */ +const char *module_get_help( const module_t *m ) { return m->psz_help; } -/***************************************************************************** - * module_Need: return the best module function, given a capability list. - ***************************************************************************** - * This function returns the module that best fits the asked capabilities. - *****************************************************************************/ -module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, - const char *psz_name, vlc_bool_t b_strict ) +module_t *module_hold (module_t *m) { - typedef struct module_list_t module_list_t; + vlc_hold (&m->vlc_gc_data); + return m; +} - struct module_list_t - { - module_t *p_module; - int i_score; - vlc_bool_t b_force; - module_list_t *p_next; - }; +void module_release (module_t *m) +{ + vlc_release (&m->vlc_gc_data); +} - module_list_t *p_list, *p_first, *p_tmp; - vlc_list_t *p_all; +/** + * Frees the flat list of VLC modules. + * @param list list obtained by module_list_get + * @param length number of items on the list + * @return nothing. + */ +void module_list_free (module_t **list) +{ + if (list == NULL) + return; - int i_which_module, i_index = 0; + for (size_t i = 0; list[i] != NULL; i++) + module_release (list[i]); + free (list); +} +/** + * Gets the flat list of VLC modules. + * @param n [OUT] pointer to the number of modules or NULL + * @return NULL-terminated table of module pointers + * (release with module_list_free()), or NULL in case of error. + */ +module_t **module_list_get (size_t *n) +{ + /* TODO: this whole module lookup is quite inefficient */ + /* Remove this and improve module_need */ + module_t **tab = NULL; + size_t i = 0; + + for (module_t *mod = p_module_bank->head; mod; mod = mod->next) + { + module_t **nt; + nt = realloc (tab, (i + 2 + mod->submodule_count) * sizeof (*tab)); + if (nt == NULL) + { + module_list_free (tab); + return NULL; + } + + tab = nt; + tab[i++] = module_hold (mod); + for (module_t *subm = mod->submodule; subm; subm = subm->next) + tab[i++] = module_hold (subm); + tab[i] = NULL; + } + if (n != NULL) + *n = i; + return tab; +} + +typedef struct module_list_t +{ module_t *p_module; + uint16_t i_score; + bool b_force; +} module_list_t; - int i_shortcuts = 0; - char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL; - vlc_bool_t b_force_backup = p_this->b_force; +static int modulecmp (const void *a, const void *b) +{ + const module_list_t *la = a, *lb = b; + /* Note that qsort() uses _ascending_ order, + * so the smallest module is the one with the biggest score. */ + return lb->i_score - la->i_score; +} + +/** + * module Need + * + * Return the best module function, given a capability list. + * + * If the p_this object doesn't have it's psz_object_name set, then + * psz_object_name will be set to the module's name, unless the user + * provided an alias using the "module name@alias" syntax in which case + * psz_object_name will be set to the alias. + * + * \param p_this the vlc object + * \param psz_capability list of capabilities needed + * \param psz_name name of the module asked + * \param b_strict TRUE yto use the strict mode + * \return the module or NULL in case of a failure + */ +module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, + const char *psz_name, bool b_strict ) +{ + stats_TimerStart( p_this, "module_need()", STATS_TIMER_MODULE_NEED ); + module_list_t *p_list; + module_t *p_module; + int i_shortcuts = 0; + char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL; + bool b_force_backup = p_this->b_force; /* Deal with variables */ if( psz_name && psz_name[0] == '$' ) { - vlc_value_t val; - var_Create( p_this, psz_name + 1, VLC_VAR_MODULE | VLC_VAR_DOINHERIT ); - var_Get( p_this, psz_name + 1, &val ); - psz_var = val.psz_string; - psz_name = psz_var; + psz_name = psz_var = var_CreateGetString( p_this, psz_name + 1 ); } /* Count how many different shortcuts were asked for */ @@ -404,6 +435,9 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, if( !strcmp( psz_name, "none" ) ) { free( psz_var ); + stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED ); return NULL; } @@ -425,54 +459,41 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, { if( !strcmp(psz_last_shortcut, "none") ) { - b_strict = VLC_TRUE; + b_strict = true; i_shortcuts--; } else if( !strcmp(psz_last_shortcut, "any") ) { - b_strict = VLC_FALSE; + b_strict = false; i_shortcuts--; } } } /* Sort the modules and test them */ - p_all = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); - p_list = malloc( p_all->i_count * sizeof( module_list_t ) ); - p_first = NULL; + size_t count; + module_t **p_all = module_list_get (&count); + p_list = malloc( count * sizeof( module_list_t ) ); unsigned i_cpu = vlc_CPU(); /* Parse the module list for capabilities and probe each of them */ - for( i_which_module = 0; i_which_module < p_all->i_count; i_which_module++ ) + count = 0; + for (size_t i = 0; (p_module = p_all[i]) != NULL; i++) { - int i_shortcut_bonus = 0; - - p_module = (module_t *)p_all->p_values[i_which_module].p_object; + bool b_shortcut_bonus = false; /* Test that this module can do what we need */ - if( !module_IsCapable( p_module, psz_capability ) ) - { - /* Don't recurse through the sub-modules because vlc_list_find() - * will list them anyway. */ + if( !module_provides( p_module, psz_capability ) ) continue; - } - /* Test if we have the required CPU */ if( (p_module->i_cpu & i_cpu) != p_module->i_cpu ) - { continue; - } /* If we required a shortcut, check this plugin provides it. */ if( i_shortcuts > 0 ) { - vlc_bool_t b_trash; const char *psz_name = psz_shortcuts; - /* Let's drop modules with a <= 0 score (unless they are - * explicitly requested) */ - b_trash = p_module->i_score <= 0; - for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- ) { for( unsigned i = 0; p_module->pp_shortcuts[i]; i++ ) @@ -486,7 +507,7 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, /* Found it */ if( c && c[1] ) psz_alias = c+1; - i_shortcut_bonus = i_short * 10000; + b_shortcut_bonus = true; goto found_shortcut; } } @@ -508,110 +529,55 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, } found_shortcut: - /* Store this new module */ - p_list[ i_index ].p_module = p_module; - p_list[ i_index ].i_score = p_module->i_score + i_shortcut_bonus; - p_list[ i_index ].b_force = i_shortcut_bonus && b_strict; - - /* 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 - { - 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++; + p_list[count].p_module = module_hold (p_module); + p_list[count].i_score = p_module->i_score; + if( b_shortcut_bonus ) + p_list[count].i_score += 10000; + p_list[count].b_force = b_shortcut_bonus && b_strict; + count++; } - msg_Dbg( p_this, "looking for %s module: %i candidate%s", psz_capability, - i_index, i_index == 1 ? "" : "s" ); + /* We can release the list, interesting modules are held */ + module_list_free (p_all); - /* Lock all candidate modules */ - p_tmp = p_first; - while( p_tmp != NULL ) - { - vlc_object_yield( p_tmp->p_module ); - p_tmp = p_tmp->p_next; - } - - /* We can release the list, interesting modules were yielded */ - vlc_list_release( p_all ); + /* Sort candidates by descending score */ + qsort (p_list, count, sizeof (p_list[0]), modulecmp); + msg_Dbg( p_this, "looking for %s module: %i candidate%s", psz_capability, + count, count == 1 ? "" : "s" ); /* Parse the linked list and use the first successful module */ - p_tmp = p_first; - while( p_tmp != NULL ) + p_module = NULL; + for (size_t i = 0; (i < count) && (p_module == NULL); i++) { + module_t *p_cand = p_list[i].p_module; #ifdef HAVE_DYNAMIC_PLUGINS /* Make sure the module is loaded in mem */ - module_t *p_module = p_tmp->p_module; - if( p_module->b_submodule ) - p_module = (module_t *)p_module->p_parent; + module_t *p_real = p_cand->b_submodule ? p_cand->parent : p_cand; - if( !p_module->b_builtin && !p_module->b_loaded ) + if( !p_real->b_builtin && !p_real->b_loaded ) { module_t *p_new_module = - AllocatePlugin( p_this, p_module->psz_filename ); + AllocatePlugin( p_this, p_real->psz_filename ); if( p_new_module ) { - CacheMerge( p_this, p_module, p_new_module ); - vlc_object_attach( p_new_module, p_module ); - DeleteModule( p_new_module, VLC_TRUE ); + CacheMerge( p_this, p_real, p_new_module ); + DeleteModule( p_new_module ); } } #endif - p_this->b_force = p_tmp->b_force; - if( p_tmp->p_module->pf_activate - && p_tmp->p_module->pf_activate( p_this ) == VLC_SUCCESS ) + p_this->b_force = p_list[i].b_force; + if( p_cand->pf_activate + && p_cand->pf_activate( p_this ) == VLC_SUCCESS ) { - break; + p_module = p_cand; + /* Release the remaining modules */ + while (++i < count) + module_release (p_list[i].p_module); } - - vlc_object_release( 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 ) - { - vlc_object_release( p_tmp->p_module ); - p_tmp = p_tmp->p_next; + else + module_release( p_cand ); } free( p_list ); @@ -621,13 +587,24 @@ found_shortcut: { msg_Dbg( p_this, "using %s module \"%s\"", psz_capability, p_module->psz_object_name ); + if( !p_this->psz_object_name ) + { + /* This assumes that p_this is the object which will be using the + * module. That's not always the case ... but it is in most cases. + */ + if( psz_alias ) + p_this->psz_object_name = strdup( psz_alias ); + else + p_this->psz_object_name = strdup( p_module->psz_object_name ); + } } - else if( p_first == NULL ) + else if( count == 0 ) { - if( !strcmp( psz_capability, "access_demux" ) ) + if( !strcmp( psz_capability, "access_demux" ) + || !strcmp( psz_capability, "vout_window" ) ) { - msg_Warn( p_this, "no %s module matched \"%s\"", - psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); + msg_Dbg( p_this, "no %s module matched \"%s\"", + psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); } else { @@ -646,31 +623,27 @@ found_shortcut: else msg_StackSet( VLC_EGENERIC, "no suitable %s module", psz_capability ); - if( p_module && !p_this->psz_object_name ) - { - /* This assumes that p_this is the object which will be using the - * module. That's not always the case ... but it is in most cases. - */ - if( psz_alias ) - p_this->psz_object_name = strdup( psz_alias ); - else - p_this->psz_object_name = strdup( p_module->psz_object_name ); - } - free( psz_shortcuts ); free( psz_var ); + stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED ); + /* Don't forget that the module is still locked */ return p_module; } -/***************************************************************************** - * module_Unneed: decrease the usage count of a module. - ***************************************************************************** - * This function must be called by the thread that called module_Need, to +/** + * Module unneed + * + * This function must be called by the thread that called module_need, to * decrease the reference count and allow for hiding of modules. - *****************************************************************************/ -void __module_Unneed( vlc_object_t * p_this, module_t * p_module ) + * \param p_this vlc object structure + * \param p_module the module structure + * \return nothing + */ +void __module_unneed( vlc_object_t * p_this, module_t * p_module ) { /* Use the close method */ if( p_module->pf_deactivate ) @@ -680,94 +653,101 @@ void __module_Unneed( vlc_object_t * p_this, module_t * p_module ) msg_Dbg( p_this, "removing module \"%s\"", p_module->psz_object_name ); - vlc_object_release( p_module ); - - return; + module_release( p_module ); } -/***************************************************************************** - * module_Find: get a pointer to a module_t given it's name. - *****************************************************************************/ -module_t *__module_Find( vlc_object_t *p_this, const char * psz_name ) +/** + * Get a pointer to a module_t given it's name. + * + * \param p_this vlc object structure + * \param psz_name the name of the module + * \return a pointer to the module or NULL in case of a failure + */ +module_t *__module_find( vlc_object_t *p_this, const char * psz_name ) { - vlc_list_t *p_list; - int i; - p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); - for( i = 0 ; i < p_list->i_count; i++) + module_t **list, *module; + + list = module_list_get (NULL); + if (!list) + return NULL; + + for (size_t i = 0; (module = list[i]) != NULL; i++) { - module_t *p_module = ((module_t *) p_list->p_values[i].p_object); - const char *psz_module_name = p_module->psz_object_name; + const char *psz_module_name = module->psz_object_name; + if( psz_module_name && !strcmp( psz_module_name, psz_name ) ) { - /* We can release the list, and return yes */ - vlc_object_yield( p_module ); - vlc_list_release( p_list ); - return p_module; + module_hold (module); + break; } } - vlc_list_release( p_list ); - return NULL; + module_list_free (list); + return module; } - -/***************************************************************************** - * module_Put: release a module_t pointer from module_Find(). - *****************************************************************************/ -void module_Put ( module_t *module ) -{ - vlc_object_release ( module ); -} - - -/***************************************************************************** - * module_Exists: tell if a module exists. - ***************************************************************************** - * This function is a boolean function that tells if a module exist or not. - *****************************************************************************/ -vlc_bool_t __module_Exists( vlc_object_t *p_this, const char * psz_name ) +/** + * Tell if a module exists and release it in thic case + * + * \param p_this vlc object structure + * \param psz_name th name of the module + * \return TRUE if the module exists + */ +bool __module_exists( vlc_object_t *p_this, const char * psz_name ) { - module_t *p_module = __module_Find( p_this, psz_name ); + module_t *p_module = __module_find( p_this, psz_name ); if( p_module ) - { - module_Put( p_module ); - return VLC_TRUE; - } - else - { - return VLC_FALSE; - } + module_release (p_module); + return p_module != NULL; } -/***************************************************************************** - * module_GetModuleNamesForCapability: Return a NULL terminated array with the - * names of the modules that have a certain capability. +/** + * GetModuleNamesForCapability + * + * Return a NULL terminated array with the names of the modules + * that have a certain capability. * Free after uses both the string and the table. - *****************************************************************************/ + * \param p_this vlc object structure + * \param psz_capability the capability asked + * \param pppsz_longname an pointer to an array of string to contain + the long names of the modules. If set to NULL the function don't use it. + * \return the NULL terminated array + */ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, - const char * psz_capability, + const char *psz_capability, char ***pppsz_longname ) { - vlc_list_t *p_list; - int i, j, count = 0; - char ** psz_ret; + size_t count = 0; + char **psz_ret; - /* Do it in two passes */ - p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); - for( i = 0 ; i < p_list->i_count; i++) + module_t **list = module_list_get (NULL); + + /* Do it in two passes : count the number of modules before */ + for (size_t i = 0; list[i]; i++) { - module_t *p_module = ((module_t *) p_list->p_values[i].p_object); + module_t *p_module = list[i]; const char *psz_module_capability = p_module->psz_capability; + if( psz_module_capability && !strcmp( psz_module_capability, psz_capability ) ) count++; } + psz_ret = malloc( sizeof(char*) * (count+1) ); if( pppsz_longname ) *pppsz_longname = malloc( sizeof(char*) * (count+1) ); - j = 0; - for( i = 0 ; i < p_list->i_count; i++) + if( !psz_ret || ( pppsz_longname && *pppsz_longname == NULL ) ) + { + free( psz_ret ); + free( *pppsz_longname ); + *pppsz_longname = NULL; + module_list_free (list); + return NULL; + } + + for (size_t i = 0, j = 0; list[i]; i++) { - module_t *p_module = ((module_t *) p_list->p_values[i].p_object); + module_t *p_module = list[i]; const char *psz_module_capability = p_module->psz_capability; + if( psz_module_capability && !strcmp( psz_module_capability, psz_capability ) ) { int k = -1; /* hack to handle submodules properly */ @@ -779,97 +759,166 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, psz_ret[j] = strdup( k>=0?p_module->pp_shortcuts[k] :p_module->psz_object_name ); if( pppsz_longname ) - (*pppsz_longname)[j] = strdup( module_GetName( p_module, VLC_TRUE ) ); + (*pppsz_longname)[j] = strdup( module_get_name( p_module, true ) ); j++; } } psz_ret[count] = NULL; - vlc_list_release( p_list ); + module_list_free (list); return psz_ret; } - -module_config_t *module_GetConfig (const module_t *module, unsigned *restrict psize) +/** + * Get the configuration of a module + * + * \param module the module + * \param psize the size of the configuration returned + * \return the configuration as an array + */ +module_config_t *module_config_get( const module_t *module, unsigned *restrict psize ) { + unsigned i,j; unsigned size = module->confsize; + module_config_t *config = malloc( size * sizeof( *config ) ); - assert (psize != NULL); - *psize = size; + assert( psize != NULL ); + *psize = 0; - module_config_t *config = malloc (size * sizeof (*config)); - if (config) - memcpy (config, module->p_config, size * sizeof (*config)); + if( !config ) + return NULL; + + for( i = 0, j = 0; i < size; i++ ) + { + const module_config_t *item = module->p_config + i; + if( item->b_internal /* internal option */ + || item->b_unsaveable /* non-modifiable option */ + || item->b_removed /* removed option */ ) + continue; + + memcpy( config + j, item, sizeof( *config ) ); + j++; + } + *psize = j; return config; } -void module_PutConfig (module_config_t *config) +/** + * Release the configuration + * + * \param the configuration + * \return nothing + */ +void module_config_free( module_config_t *config ) { - free (config); + free( config ); } /***************************************************************************** * Following functions are local. *****************************************************************************/ -/***************************************************************************** - * AllocateAllPlugins: load all plugin modules we can find. + /***************************************************************************** + * copy_next_paths_token: from a PATH_SEP_CHAR (a ':' or a ';') separated paths + * return first path. *****************************************************************************/ -#ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins( vlc_object_t *p_this ) +static char * copy_next_paths_token( char * paths, char ** remaining_paths ) { - /* Yes, there are two NULLs because we replace one with "plugin-path". */ -#if defined( WIN32 ) || defined( UNDER_CE ) - const char *path[] = { "modules", "", "plugins", NULL, NULL }; -#else - const char *path[] = { "modules", PLUGIN_PATH, "plugins", NULL, NULL }; -#endif + char * path; + int i, done; + bool escaped = false; - const char *const *ppsz_path; + assert( paths ); - /* If the user provided a plugin path, we add it to the list */ - char *userpath = config_GetPsz( p_this, "plugin-path" ); - path[sizeof(path)/sizeof(path[0]) - 2] = userpath; + /* Alloc a buffer to store the path */ + path = malloc( strlen( paths ) + 1 ); + if( !path ) return NULL; - for (ppsz_path = path; *ppsz_path != NULL; ppsz_path++) + /* Look for PATH_SEP_CHAR (a ':' or a ';') */ + for( i = 0, done = 0 ; paths[i]; i++ ) { - char *psz_fullpath; - - if (!**ppsz_path) continue; - -#if defined( SYS_BEOS ) || defined( __APPLE__ ) || defined( WIN32 ) - - /* Handle relative as well as absolute paths */ + /* Take care of \\ and \: or \; escapement */ + if( escaped ) + { + escaped = false; + path[done++] = paths[i]; + } #ifdef WIN32 - if( (*ppsz_path)[0] != '\\' && (*ppsz_path)[0] != '/' && - (*ppsz_path)[1] != ':' ) + else if( paths[i] == '/' ) + escaped = true; #else - if( (*ppsz_path)[0] != '/' ) + else if( paths[i] == '\\' ) + escaped = true; #endif - { - if( 0>= asprintf( &psz_fullpath, "%s"DIR_SEP"%s", - vlc_global()->psz_vlcpath, *ppsz_path) ) - psz_fullpath = NULL; - } + else if( paths[i] == PATH_SEP_CHAR ) + break; else + path[done++] = paths[i]; + } + path[done++] = 0; + + /* Return the remaining paths */ + if( remaining_paths ) { + *remaining_paths = paths[i] ? &paths[i]+1 : NULL; + } + + return path; +} + +extern char *psz_vlcpath = NULL; + +/***************************************************************************** + * AllocateAllPlugins: load all plugin modules we can find. + *****************************************************************************/ +#ifdef HAVE_DYNAMIC_PLUGINS +static void AllocateAllPlugins( vlc_object_t *p_this ) +{ + const char *vlcpath = psz_vlcpath; + int count,i; + char * path; + vlc_array_t *arraypaths = vlc_array_new(); + + /* Contruct the special search path for system that have a relocatable + * executable. Set it to /modules and /plugins. */ + + if( vlcpath && asprintf( &path, "%s" DIR_SEP "modules", vlcpath ) != -1 ) + vlc_array_append( arraypaths, path ); + if( vlcpath && asprintf( &path, "%s" DIR_SEP "plugins", vlcpath ) != -1 ) + vlc_array_append( arraypaths, path ); +#ifndef WIN32 + vlc_array_append( arraypaths, strdup( PLUGIN_PATH ) ); #endif - psz_fullpath = strdup( *ppsz_path ); - if( psz_fullpath == NULL ) + /* If the user provided a plugin path, we add it to the list */ + char *userpaths = config_GetPsz( p_this, "plugin-path" ); + char *paths_iter; + + for( paths_iter = userpaths; paths_iter; ) + { + path = copy_next_paths_token( paths_iter, &paths_iter ); + if( path ) + vlc_array_append( arraypaths, path ); + } + + count = vlc_array_count( arraypaths ); + for( i = 0 ; i < count ; i++ ) + { + path = vlc_array_item_at_index( arraypaths, i ); + if( !path ) continue; - msg_Dbg( p_this, "recursively browsing `%s'", psz_fullpath ); + msg_Dbg( p_this, "recursively browsing `%s'", path ); /* Don't go deeper than 5 subdirectories */ - AllocatePluginDir( p_this, psz_fullpath, 5 ); + AllocatePluginDir( p_this, path, 5 ); - free( psz_fullpath ); + free( path ); } - /* Free plugin-path */ - free( userpath ); + vlc_array_destroy( arraypaths ); + free( userpaths ); } /***************************************************************************** @@ -1005,7 +1054,7 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, i_dirlen = strlen( psz_dir ); /* Parse the directory and try to load all files it contains. */ - while( !p_this->p_libvlc->b_die && (file = readdir( dir )) ) + while( !p_this->p_libvlc->b_die && ( file = readdir( dir ) ) ) { struct stat statbuf; unsigned int i_len; @@ -1056,8 +1105,8 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, * AllocatePluginFile: load a module into memory and initialize it. ***************************************************************************** * This function loads a dynamically loadable module and allocates a structure - * for its information data. The module can then be handled by module_Need - * and module_Unneed. It can be removed by DeleteModule. + * for its information data. The module can then be handled by module_need + * and module_unneed. It can be removed by DeleteModule. *****************************************************************************/ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, int64_t i_file_time, int64_t i_file_size ) @@ -1069,7 +1118,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, * Check our plugins cache first then load plugin if needed */ p_cache_entry = - CacheFind( p_this, psz_file, i_file_time, i_file_size ); + CacheFind( psz_file, i_file_time, i_file_size ); if( !p_cache_entry ) { @@ -1087,7 +1136,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, module_config_t *p_item = NULL, *p_end = NULL; p_module = p_cache_entry->p_module; - p_module->b_loaded = VLC_FALSE; + p_module->b_loaded = false; /* For now we force loading if the module's config contains * callbacks or actions. @@ -1102,27 +1151,25 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, } } if( p_module == p_cache_entry->p_module ) - p_cache_entry->b_used = VLC_TRUE; + p_cache_entry->b_used = true; } } if( p_module ) { - libvlc_global_data_t *p_libvlc_global = vlc_global(); - /* Everything worked fine ! * The module is ready to be added to the list. */ - p_module->b_builtin = VLC_FALSE; + p_module->b_builtin = false; /* msg_Dbg( p_this, "plugin \"%s\", %s", p_module->psz_object_name, p_module->psz_longname ); */ + p_module->next = p_module_bank->head; + p_module_bank->head = p_module; - vlc_object_attach( p_module, p_libvlc_global->p_module_bank ); - - if( !p_libvlc_global->p_module_bank->b_cache ) + if( !p_module_bank->b_cache ) return 0; -#define p_bank p_libvlc_global->p_module_bank +#define p_bank p_module_bank /* Add entry to cache */ p_bank->pp_cache = realloc( p_bank->pp_cache, (p_bank->i_cache + 1) * sizeof(void *) ); @@ -1133,9 +1180,10 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, p_bank->pp_cache[p_bank->i_cache]->i_time = i_file_time; p_bank->pp_cache[p_bank->i_cache]->i_size = i_file_size; p_bank->pp_cache[p_bank->i_cache]->b_junk = p_module ? 0 : 1; - p_bank->pp_cache[p_bank->i_cache]->b_used = VLC_TRUE; + p_bank->pp_cache[p_bank->i_cache]->b_used = true; p_bank->pp_cache[p_bank->i_cache]->p_module = p_module; p_bank->i_cache++; +#undef p_bank } return p_module ? 0 : -1; @@ -1145,8 +1193,8 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, * AllocatePlugin: load a module into memory and initialize it. ***************************************************************************** * This function loads a dynamically loadable module and allocates a structure - * for its information data. The module can then be handled by module_Need - * and module_Unneed. It can be removed by DeleteModule. + * for its information data. The module can then be handled by module_need + * and module_unneed. It can be removed by DeleteModule. *****************************************************************************/ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) { @@ -1161,7 +1209,6 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) p_module = vlc_module_create( p_this ); if( p_module == NULL ) { - msg_Err( p_this, "out of memory" ); module_Unload( handle ); return NULL; } @@ -1169,13 +1216,13 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) /* We need to fill these since they may be needed by module_Call() */ p_module->psz_filename = psz_file; p_module->handle = handle; - p_module->b_loaded = VLC_TRUE; + p_module->b_loaded = true; /* Initialize the module: fill p_module, default config */ - if( module_Call( p_module ) != 0 ) + if( module_Call( p_this, p_module ) != 0 ) { /* We couldn't call module_init() */ - vlc_object_destroy( p_module ); + module_release( p_module ); module_Unload( handle ); return NULL; } @@ -1184,7 +1231,7 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) p_module->psz_filename = strdup( p_module->psz_filename ); /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->b_builtin = VLC_FALSE; + p_module->b_builtin = false; return p_module; } @@ -1197,8 +1244,7 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) *****************************************************************************/ static void DupModule( module_t *p_module ) { - const char **pp_shortcut; - int i_submodule; + char **pp_shortcut; for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { @@ -1207,7 +1253,6 @@ static void DupModule( module_t *p_module ) /* We strdup() these entries so that they are still valid when the * module is unloaded. */ - p_module->psz_object_name = strdup( p_module->psz_object_name ); p_module->psz_capability = strdup( p_module->psz_capability ); p_module->psz_shortname = p_module->psz_shortname ? strdup( p_module->psz_shortname ) : NULL; @@ -1215,10 +1260,8 @@ static void DupModule( module_t *p_module ) p_module->psz_help = p_module->psz_help ? strdup( p_module->psz_help ) : NULL; - for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) - { - DupModule( (module_t*)p_module->pp_children[ i_submodule ] ); - } + for (module_t *subm = p_module->submodule; subm; subm = subm->next) + DupModule (subm); } /***************************************************************************** @@ -1228,24 +1271,20 @@ static void DupModule( module_t *p_module ) *****************************************************************************/ static void UndupModule( module_t *p_module ) { - const char **pp_shortcut; - int i_submodule; + char **pp_shortcut; - for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) - { - UndupModule( (module_t*)p_module->pp_children[ i_submodule ] ); - } + for (module_t *subm = p_module->submodule; subm; subm = subm->next) + UndupModule (subm); for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { - free( (void*)*pp_shortcut ); + free( *pp_shortcut ); } - free( (void*)p_module->psz_object_name ); free( p_module->psz_capability ); - free( (void*)p_module->psz_shortname ); - free( (void*)p_module->psz_longname ); - free( (void*)p_module->psz_help ); + FREENULL( p_module->psz_shortname ); + free( p_module->psz_longname ); + FREENULL( p_module->psz_help ); } #endif /* HAVE_DYNAMIC_PLUGINS */ @@ -1254,8 +1293,8 @@ static void UndupModule( module_t *p_module ) * AllocateBuiltinModule: initialize a builtin module. ***************************************************************************** * This function registers a builtin module and allocates a structure - * for its information data. The module can then be handled by module_Need - * and module_Unneed. It can be removed by DeleteModule. + * for its information data. The module can then be handled by module_need + * and module_unneed. It can be removed by DeleteModule. *****************************************************************************/ static int AllocateBuiltinModule( vlc_object_t * p_this, int ( *pf_entry ) ( module_t * ) ) @@ -1266,10 +1305,7 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, * allocate a structure for it */ p_module = vlc_module_create( p_this ); if( p_module == NULL ) - { - msg_Err( p_this, "out of memory" ); return -1; - } /* Initialize the module : fill p_module->psz_object_name, etc. */ if( pf_entry( p_module ) != 0 ) @@ -1277,18 +1313,20 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, /* With a well-written module we shouldn't have to print an * additional error message here, but just make sure. */ msg_Err( p_this, "failed calling entry point in builtin module" ); - vlc_object_destroy( p_module ); + module_release( p_module ); return -1; } /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->b_builtin = VLC_TRUE; + p_module->b_builtin = true; + /* LOCK */ + p_module->next = p_module_bank->head; + p_module_bank->head = p_module; + /* UNLOCK */ /* msg_Dbg( p_this, "builtin \"%s\", %s", p_module->psz_object_name, p_module->psz_longname ); */ - vlc_object_attach( p_module, vlc_global()->p_module_bank ); - return 0; } @@ -1297,11 +1335,16 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, ***************************************************************************** * This function can only be called if the module isn't being used. *****************************************************************************/ -static int DeleteModule( module_t * p_module, vlc_bool_t b_detach ) +static void DeleteModule( module_t * p_module ) { - if( !p_module ) return VLC_EGENERIC; - if( b_detach ) - vlc_object_detach( p_module ); + assert( p_module ); + + /* Unlist the module (if it is in the list) */ + module_t **pp_self = &p_module_bank->head; + while (*pp_self != NULL && *pp_self != p_module) + pp_self = &((*pp_self)->next); + if (*pp_self) + *pp_self = p_module->next; /* We free the structures that we strdup()ed in Allocate*Module(). */ #ifdef HAVE_DYNAMIC_PLUGINS @@ -1317,15 +1360,13 @@ static int DeleteModule( module_t * p_module, vlc_bool_t b_detach ) #endif /* Free and detach the object's children */ - while( p_module->i_children ) + while (p_module->submodule) { - vlc_object_t *p_this = p_module->pp_children[0]; - vlc_object_detach( p_this ); - vlc_object_destroy( p_this ); + module_t *submodule = p_module->submodule; + p_module->submodule = submodule->next; + module_release (submodule); } config_Free( p_module ); - vlc_object_destroy( p_module ); - p_module = NULL; - return 0; + module_release( p_module ); }