X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmodules%2Fmodules.c;h=dd026d02449fd0cae2d62bd6a74eb7f4f7e4ca72;hb=a6acf806b45fdbb7244297faaf0e902811c9e6d3;hp=eeabe10ef65e768cfc7204de7a85baba9362ce7c;hpb=6391721b5a50240dfc9da84d4bac3ba9759f33df;p=vlc diff --git a/src/modules/modules.c b/src/modules/modules.c index eeabe10ef6..dd026d0244 100644 --- a/src/modules/modules.c +++ b/src/modules/modules.c @@ -88,19 +88,25 @@ #include "vlc_arrays.h" #include "modules/modules.h" -#include "modules/builtin.h" + +static module_bank_t *p_module_bank = NULL; +static vlc_mutex_t module_lock = VLC_STATIC_MUTEX; + +int vlc_entry__main( module_t * ); /***************************************************************************** * Local prototypes *****************************************************************************/ #ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins ( vlc_object_t * ); -static void AllocatePluginDir ( vlc_object_t *, const char *, int ); -static int AllocatePluginFile ( vlc_object_t *, char *, int64_t, int64_t ); -static module_t * AllocatePlugin( vlc_object_t *, char * ); +static void AllocateAllPlugins( vlc_object_t *, module_bank_t * ); +static void AllocatePluginDir( vlc_object_t *, module_bank_t *, const char *, + unsigned ); +static int AllocatePluginFile( vlc_object_t *, module_bank_t *, const char *, + int64_t, int64_t ); +static module_t * AllocatePlugin( vlc_object_t *, const char * ); #endif static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) ); -static void DeleteModule ( module_t *, bool ); +static void DeleteModule ( module_bank_t *, module_t * ); #ifdef HAVE_DYNAMIC_PLUGINS static void DupModule ( module_t * ); static void UndupModule ( module_t * ); @@ -117,23 +123,20 @@ static void UndupModule ( module_t * ); void __module_InitBank( vlc_object_t *p_this ) { module_bank_t *p_bank = NULL; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); + vlc_mutex_lock( &module_lock ); - if( p_libvlc_global->p_module_bank == NULL ) + if( p_module_bank == NULL ) { - p_bank = vlc_custom_create( p_this, sizeof(module_bank_t), - VLC_OBJECT_GENERIC, "module bank"); + 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->b_cache = p_bank->b_cache_dirty = false; + p_bank->head = NULL; /* Everything worked, attach the object */ - p_libvlc_global->p_module_bank = p_bank; - vlc_object_attach( p_bank, p_libvlc_global ); + 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 @@ -143,9 +146,9 @@ void __module_InitBank( vlc_object_t *p_this ) AllocateBuiltinModule( p_this, vlc_entry__main ); } else - p_libvlc_global->p_module_bank->i_usage++; + p_module_bank->i_usage++; - vlc_mutex_unlock( lock ); + vlc_mutex_unlock( &module_lock ); } @@ -159,35 +162,31 @@ void __module_InitBank( vlc_object_t *p_this ) */ void __module_EndBank( vlc_object_t *p_this ) { - module_t * p_next = NULL; - libvlc_global_data_t *p_libvlc_global = vlc_global(); + module_bank_t *p_bank; - vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); - if( !p_libvlc_global->p_module_bank ) - { - vlc_mutex_unlock( lock ); - return; - } - if( --p_libvlc_global->p_module_bank->i_usage ) + /* Save the configuration */ + config_AutoSaveConfigFile( p_this ); + + vlc_mutex_lock( &module_lock ); + p_bank = p_module_bank; + assert (p_bank != NULL); + if( --p_bank->i_usage > 0 ) { - vlc_mutex_unlock( lock ); + vlc_mutex_unlock( &module_lock ); return; } - vlc_mutex_unlock( lock ); - - /* Save the configuration */ - config_AutoSaveConfigFile( p_this ); + p_module_bank = NULL; + vlc_mutex_unlock( &module_lock ); #ifdef HAVE_DYNAMIC_PLUGINS -# define p_bank p_libvlc_global->p_module_bank - if( p_bank->b_cache ) CacheSave( p_this ); + if( p_bank->b_cache ) + CacheSave( p_this, p_bank ); 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, + 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; @@ -209,45 +208,15 @@ 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( vlc_internals( p_libvlc_global->p_module_bank )->i_children ) - { - p_next = (module_t *)vlc_internals( p_libvlc_global->p_module_bank )->pp_children[0]; - DeleteModule( p_next, true ); - } - - vlc_object_release( p_libvlc_global->p_module_bank ); - p_libvlc_global->p_module_bank = NULL; -} - -/** - * 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 ) -{ - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); - if( p_libvlc_global->p_module_bank->b_builtins ) - { - vlc_mutex_unlock( lock ); - return; - } - p_libvlc_global->p_module_bank->b_builtins = true; - vlc_mutex_unlock( lock ); + while( p_bank->head != NULL ) + DeleteModule( p_bank, p_bank->head ); - msg_Dbg( p_this, "checking builtin modules" ); - ALLOCATE_ALL_BUILTINS(); + free( p_bank ); } +#undef module_LoadPlugins /** * Load all plugins * @@ -256,29 +225,26 @@ void __module_LoadBuiltins( vlc_object_t * p_this ) * \param p_this vlc object structure * \return nothing */ -void __module_LoadPlugins( vlc_object_t * p_this ) +void module_LoadPlugins( vlc_object_t * p_this, bool b_cache_delete ) { #ifdef HAVE_DYNAMIC_PLUGINS - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); - if( p_libvlc_global->p_module_bank->b_plugins ) + vlc_mutex_lock( &module_lock ); + if( p_module_bank->b_plugins ) { - vlc_mutex_unlock( lock ); + vlc_mutex_unlock( &module_lock ); return; } - p_libvlc_global->p_module_bank->b_plugins = true; - vlc_mutex_unlock( lock ); + p_module_bank->b_plugins = true; + vlc_mutex_unlock( &module_lock ); msg_Dbg( p_this, "checking plugin modules" ); + p_module_bank->b_cache = config_GetInt( p_this, "plugins-cache" ) > 0; - if( config_GetInt( p_this, "plugins-cache" ) ) - p_libvlc_global->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 || b_cache_delete ) + CacheLoad( p_this, p_module_bank, b_cache_delete ); - AllocateAllPlugins( p_this ); + /* FIXME: race - do this under the lock */ + AllocateAllPlugins( p_this, p_module_bank ); #endif } @@ -289,7 +255,7 @@ void __module_LoadPlugins( vlc_object_t * p_this ) * \param cap the capability to check * \return TRUE if the module have the capability */ -bool module_IsCapable( const module_t *m, const char *cap ) +bool module_provides( const module_t *m, const char *cap ) { return !strcmp( m->psz_capability, cap ); } @@ -300,7 +266,7 @@ bool module_IsCapable( const module_t *m, const char *cap ) * \param m the module * \return the module name */ -const char *module_GetObjName( const module_t *m ) +const char *module_get_object( const module_t *m ) { return m->psz_object_name; } @@ -312,7 +278,7 @@ const char *module_GetObjName( const module_t *m ) * \param long_name TRUE to have the long name of the module * \return the short or long name of the module */ -const char *module_GetName( const module_t *m, bool long_name ) +const char *module_get_name( const module_t *m, bool long_name ) { if( long_name && ( m->psz_longname != NULL) ) return m->psz_longname; @@ -326,56 +292,141 @@ const char *module_GetName( const module_t *m, bool long_name ) * \param m the module * \return the help */ -const char *module_GetHelp( const module_t *m ) +const char *module_get_help( const module_t *m ) { return m->psz_help; } +/** + * Get the capability for a module + * + * \param m the module + * return the capability + */ +const char *module_get_capability( const module_t *m ) +{ + return m->psz_capability; +} + +/** + * Get the score for a module + * + * \param m the module + * return the score for the capability + */ +int module_get_score( const module_t *m ) +{ + return m->i_score; +} + +module_t *module_hold (module_t *m) +{ + vlc_hold (&m->vlc_gc_data); + return m; +} + +void module_release (module_t *m) +{ + vlc_release (&m->vlc_gc_data); +} + +/** + * 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; + + 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; + + assert (p_module_bank); + 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; + int16_t i_score; + bool b_force; +} module_list_t; + +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, +module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, const char *psz_name, bool b_strict ) { - typedef struct module_list_t module_list_t; - - stats_TimerStart( p_this, "module_Need()", STATS_TIMER_MODULE_NEED ); - - struct module_list_t - { - module_t *p_module; - int i_score; - bool b_force; - module_list_t *p_next; - }; - - module_list_t *p_list, *p_first, *p_tmp; - vlc_list_t *p_all; - - int i_which_module, i_index = 0; + stats_TimerStart( p_this, "module_need()", STATS_TIMER_MODULE_NEED ); + module_list_t *p_list; module_t *p_module; - - int i_shortcuts = 0; + 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 */ @@ -423,42 +474,29 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, } /* 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 ) { - bool 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++ ) @@ -472,7 +510,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; } } @@ -494,110 +532,61 @@ 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); +#ifdef WIN32 + /* FIXME: Remove this hack after finding a general solution for %z's */ + msg_Dbg( p_this, "looking for %s module: %u candidate%s", psz_capability, + count, count == 1 ? "" : "s" ); +#else + msg_Dbg( p_this, "looking for %s module: %zu candidate%s", psz_capability, + count, count == 1 ? "" : "s" ); +#endif /* 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, true ); + CacheMerge( p_this, p_real, p_new_module ); + DeleteModule( p_module_bank, 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 ); @@ -607,13 +596,25 @@ 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, "stream_filter" ) + || !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 { @@ -632,17 +633,6 @@ 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 ); @@ -657,13 +647,13 @@ found_shortcut: /** * Module unneed * - * This function must be called by the thread that called module_Need, to + * This function must be called by the thread that called module_need, to * decrease the reference count and allow for hiding of modules. * \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 ) +void __module_unneed( vlc_object_t * p_this, module_t * p_module ) { /* Use the close method */ if( p_module->pf_deactivate ) @@ -673,69 +663,84 @@ 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 ); + module_release( p_module ); } /** * 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 ) +module_t *module_find( 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; } - /** - * Release a module_t pointer from module_Find(). + * Tell if a module exists and release it in thic case * - * \param module the module to release - * \return nothing + * \param psz_name th name of the module + * \return TRUE if the module exists */ -void module_Put( module_t *module ) +bool module_exists (const char * psz_name) { - vlc_object_release( module ); + module_t *p_module = module_find (psz_name); + if( p_module ) + module_release (p_module); + return p_module != NULL; } - /** - * Tell if a module exists and release it in thic case + * Get a pointer to a module_t that matches a shortcut. + * This is a temporary hack for SD. Do not re-use (generally multiple modules + * can have the same shortcut, so this is *broken* - use module_need()!). * - * \param p_this vlc object structure - * \param psz_name th name of the module - * \return TRUE if the module exists + * \param psz_shortcut shortcut of the module + * \param psz_cap capability of the module + * \return a pointer to the module or NULL in case of a failure */ -bool __module_Exists( vlc_object_t *p_this, const char * psz_name ) +module_t *module_find_by_shortcut (const char *psz_shortcut) { - module_t *p_module = __module_Find( p_this, psz_name ); - if( p_module ) - { - module_Put( p_module ); - return true; - } - else + module_t **list, *module; + + list = module_list_get (NULL); + if (!list) + return NULL; + + for (size_t i = 0; (module = list[i]) != NULL; i++) { - return false; + for (size_t j = 0; + (module->pp_shortcuts[j] != NULL) && (j < MODULE_SHORTCUT_MAX); + j++) + { + if (!strcmp (module->pp_shortcuts[j], psz_shortcut)) + { + module_hold (module); + goto out; + } + } } +out: + module_list_free (list); + return module; } /** @@ -744,26 +749,25 @@ bool __module_Exists( vlc_object_t *p_this, const char * psz_name ) * 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, - char ***pppsz_longname ) +char ** module_GetModulesNamesForCapability( const char *psz_capability, + char ***pppsz_longname ) { - vlc_list_t *p_list; - int i, j, count = 0; + size_t count = 0; char **psz_ret; + module_t **list = module_list_get (NULL); + /* Do it in two passes : count the number of modules before */ - p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); - for( i = 0 ; i < p_list->i_count; i++) + 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++; } @@ -774,17 +778,20 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, if( !psz_ret || ( pppsz_longname && *pppsz_longname == NULL ) ) { free( psz_ret ); - free( *pppsz_longname ); - *pppsz_longname = NULL; - vlc_list_release( p_list ); + if( pppsz_longname ) + { + free( *pppsz_longname ); + *pppsz_longname = NULL; + } + module_list_free (list); return NULL; } - j = 0; - for( i = 0 ; i < p_list->i_count; i++) + 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 */ @@ -796,13 +803,13 @@ 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, 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; } @@ -814,7 +821,7 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, * \param psize the size of the configuration returned * \return the configuration as an array */ -module_config_t *module_GetConfig( const module_t *module, unsigned *restrict psize ) +module_config_t *module_config_get( const module_t *module, unsigned *restrict psize ) { unsigned i,j; unsigned size = module->confsize; @@ -848,7 +855,7 @@ module_config_t *module_GetConfig( const module_t *module, unsigned *restrict ps * \param the configuration * \return nothing */ -void module_PutConfig( module_config_t *config ) +void module_config_free( module_config_t *config ) { free( config ); } @@ -874,14 +881,21 @@ static char * copy_next_paths_token( char * paths, char ** remaining_paths ) if( !path ) return NULL; /* Look for PATH_SEP_CHAR (a ':' or a ';') */ - for( i = 0, done = 0 ; paths[i]; i++ ) { + for( i = 0, done = 0 ; paths[i]; i++ ) + { /* Take care of \\ and \: or \; escapement */ - if( escaped ) { + if( escaped ) + { escaped = false; path[done++] = paths[i]; } +#ifdef WIN32 + else if( paths[i] == '/' ) + escaped = true; +#else else if( paths[i] == '\\' ) escaped = true; +#endif else if( paths[i] == PATH_SEP_CHAR ) break; else @@ -897,13 +911,15 @@ static char * copy_next_paths_token( char * paths, char ** remaining_paths ) return path; } +char *psz_vlcpath = NULL; + /***************************************************************************** * AllocateAllPlugins: load all plugin modules we can find. *****************************************************************************/ #ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins( vlc_object_t *p_this ) +static void AllocateAllPlugins( vlc_object_t *p_this, module_bank_t *p_bank ) { - const char *vlcpath = vlc_global()->psz_vlcpath; + const char *vlcpath = psz_vlcpath; int count,i; char * path; vlc_array_t *arraypaths = vlc_array_new(); @@ -940,7 +956,7 @@ static void AllocateAllPlugins( vlc_object_t *p_this ) msg_Dbg( p_this, "recursively browsing `%s'", path ); /* Don't go deeper than 5 subdirectories */ - AllocatePluginDir( p_this, path, 5 ); + AllocatePluginDir( p_this, p_bank, path, 5 ); free( path ); } @@ -952,8 +968,8 @@ static void AllocateAllPlugins( vlc_object_t *p_this ) /***************************************************************************** * AllocatePluginDir: recursively parse a directory to look for plugins *****************************************************************************/ -static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, - int i_maxdepth ) +static void AllocatePluginDir( vlc_object_t *p_this, module_bank_t *p_bank, + const char *psz_dir, unsigned i_maxdepth ) { /* FIXME: Needs to be ported to wide char on ALL Windows builds */ #ifdef WIN32 @@ -977,10 +993,8 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, #endif char * psz_file; - if( p_this->p_libvlc->b_die || i_maxdepth < 0 ) - { + if( i_maxdepth == 0 ) return; - } #if defined( UNDER_CE ) || defined( _MSC_VER ) #ifdef UNDER_CE @@ -1102,7 +1116,7 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, i_stat = stat( psz_file, &statbuf ); if( !i_stat && statbuf.st_mode & S_IFDIR ) { - AllocatePluginDir( p_this, psz_file, i_maxdepth - 1 ); + AllocatePluginDir( p_this, p_bank, psz_file, i_maxdepth - 1 ); } else if( i_len > strlen( LIBEXT ) /* We only load files ending with LIBEXT */ @@ -1117,7 +1131,7 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, i_size = statbuf.st_size; } - AllocatePluginFile( p_this, psz_file, i_time, i_size ); + AllocatePluginFile( p_this, p_bank, psz_file, i_time, i_size ); } free( psz_file ); @@ -1133,10 +1147,11 @@ 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, +static int AllocatePluginFile( vlc_object_t * p_this, module_bank_t *p_bank, + const char *psz_file, int64_t i_file_time, int64_t i_file_size ) { module_t * p_module = NULL; @@ -1145,9 +1160,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( psz_file, i_file_time, i_file_size ); - + p_cache_entry = CacheFind( p_bank, psz_file, i_file_time, i_file_size ); if( !p_cache_entry ) { p_module = AllocatePlugin( p_this, psz_file ); @@ -1185,21 +1198,18 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, 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 = false; /* msg_Dbg( p_this, "plugin \"%s\", %s", p_module->psz_object_name, p_module->psz_longname ); */ + p_module->next = p_bank->head; + p_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 /* Add entry to cache */ p_bank->pp_cache = realloc( p_bank->pp_cache, (p_bank->i_cache + 1) * sizeof(void *) ); @@ -1222,10 +1232,10 @@ 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 ) +static module_t * AllocatePlugin( vlc_object_t * p_this, const char *psz_file ) { module_t * p_module = NULL; module_handle_t handle; @@ -1238,27 +1248,25 @@ 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; } - /* We need to fill these since they may be needed by module_Call() */ - p_module->psz_filename = psz_file; + p_module->psz_filename = strdup( psz_file ); p_module->handle = handle; 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_release( p_module ); + free( p_module->psz_filename ); + module_release( p_module ); module_Unload( handle ); return NULL; } DupModule( p_module ); - 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 = false; @@ -1275,7 +1283,6 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) static void DupModule( module_t *p_module ) { char **pp_shortcut; - int i_submodule; for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { @@ -1291,10 +1298,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 < vlc_internals( p_module )->i_children; i_submodule++ ) - { - DupModule( (module_t*)vlc_internals( p_module )->pp_children[ i_submodule ] ); - } + for (module_t *subm = p_module->submodule; subm; subm = subm->next) + DupModule (subm); } /***************************************************************************** @@ -1305,23 +1310,19 @@ static void DupModule( module_t *p_module ) static void UndupModule( module_t *p_module ) { char **pp_shortcut; - int i_submodule; - for( i_submodule = 0; i_submodule < vlc_internals( p_module )->i_children; i_submodule++ ) - { - UndupModule( (module_t*)vlc_internals( 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( *pp_shortcut ); } - FREENULL( p_module->psz_object_name ); free( p_module->psz_capability ); - free( p_module->psz_shortname ); + FREENULL( p_module->psz_shortname ); free( p_module->psz_longname ); - free( p_module->psz_help ); + FREENULL( p_module->psz_help ); } #endif /* HAVE_DYNAMIC_PLUGINS */ @@ -1330,8 +1331,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 * ) ) @@ -1342,10 +1343,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 ) @@ -1353,18 +1351,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_release( 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 = 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; } @@ -1373,12 +1373,16 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, ***************************************************************************** * This function can only be called if the module isn't being used. *****************************************************************************/ -static void DeleteModule( module_t * p_module, bool b_detach ) +static void DeleteModule( module_bank_t *p_bank, module_t * p_module ) { assert( p_module ); - if( b_detach ) - vlc_object_detach( p_module ); + /* Unlist the module (if it is in the list) */ + module_t **pp_self = &p_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 @@ -1394,13 +1398,13 @@ static void DeleteModule( module_t * p_module, bool b_detach ) #endif /* Free and detach the object's children */ - while( vlc_internals( p_module )->i_children ) + while (p_module->submodule) { - vlc_object_t *p_this = vlc_internals( p_module )->pp_children[0]; - vlc_object_detach( p_this ); - vlc_object_release( p_this ); + module_t *submodule = p_module->submodule; + p_module->submodule = submodule->next; + module_release (submodule); } config_Free( p_module ); - vlc_object_release( p_module ); + module_release( p_module ); }