#include "modules/modules.h"
#include "modules/builtin.h"
-module_bank_t *p_module_bank;
+static module_bank_t *p_module_bank = NULL;
+static vlc_mutex_t module_lock = VLC_STATIC_MUTEX;
/*****************************************************************************
* Local prototypes
static module_t * AllocatePlugin( vlc_object_t *, char * );
#endif
static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) );
-static void DeleteModule ( module_t * );
+static void DeleteModule ( module_bank_t *, module_t * );
#ifdef HAVE_DYNAMIC_PLUGINS
static void DupModule ( module_t * );
static void UndupModule ( module_t * );
{
module_bank_t *p_bank = NULL;
- vlc_mutex_lock( &global_lock );
+ vlc_mutex_lock( &module_lock );
if( p_module_bank == NULL )
{
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 */
else
p_module_bank->i_usage++;
- vlc_mutex_unlock( &global_lock );
+ vlc_mutex_unlock( &module_lock );
}
{
module_bank_t *p_bank;
- vlc_mutex_lock( &global_lock );
+ /* 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( &global_lock );
+ vlc_mutex_unlock( &module_lock );
return;
}
- /*FIXME: For thread safety, we need to:
- p_module_bank = NULL; - immediately, but that will crash the cache */
- vlc_mutex_unlock( &global_lock );
-
- /* Save the configuration */
- config_AutoSaveConfigFile( p_this );
+ p_module_bank = NULL;
+ vlc_mutex_unlock( &module_lock );
#ifdef HAVE_DYNAMIC_PLUGINS
- 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(
+ 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] );
#endif
while( p_bank->head != NULL )
- DeleteModule( p_bank->head );
+ DeleteModule( p_bank, p_bank->head );
- p_module_bank = NULL; /* FIXME: do this inside the lock */
free( p_bank );
}
*/
void __module_LoadBuiltins( vlc_object_t * p_this )
{
- vlc_mutex_lock( &global_lock );
+ vlc_mutex_lock( &module_lock );
if( p_module_bank->b_builtins )
{
- vlc_mutex_unlock( &global_lock );
+ vlc_mutex_unlock( &module_lock );
return;
}
p_module_bank->b_builtins = true;
- vlc_mutex_unlock( &global_lock );
+ vlc_mutex_unlock( &module_lock );
msg_Dbg( p_this, "checking builtin modules" );
+ /* FIXME: race here - do this under the lock!! */
ALLOCATE_ALL_BUILTINS();
}
+#undef module_LoadPlugins
/**
* Load all plugins
*
* \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
- vlc_mutex_lock( &global_lock );
+ vlc_mutex_lock( &module_lock );
if( p_module_bank->b_plugins )
{
- vlc_mutex_unlock( &global_lock );
+ vlc_mutex_unlock( &module_lock );
return;
}
p_module_bank->b_plugins = true;
- vlc_mutex_unlock( &global_lock );
+ 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_module_bank->b_cache = true;
-
- if( p_module_bank->b_cache ||
- 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 );
+ /* FIXME: race - do this under the lock */
AllocateAllPlugins( p_this );
#endif
}
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);
/**
* Frees the flat list of VLC modules.
- * @param list list obtained by module_list_get
+ * @param list list obtained by module_list_get()
* @param length number of items on the list
* @return nothing.
*/
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;
typedef struct module_list_t
{
module_t *p_module;
- uint16_t i_score;
+ int16_t i_score;
bool b_force;
} module_list_t;
/* 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,
+#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_module = NULL;
if( p_new_module )
{
CacheMerge( p_this, p_real, p_new_module );
- DeleteModule( p_new_module );
+ DeleteModule( p_module_bank, p_new_module );
}
}
#endif
else if( count == 0 )
{
if( !strcmp( psz_capability, "access_demux" )
+ || !strcmp( psz_capability, "stream_filter" )
|| !strcmp( psz_capability, "vout_window" ) )
{
msg_Dbg( p_this, "no %s module matched \"%s\"",
* \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 )
{
module_t **list, *module;
* \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 )
+bool module_exists (const char * psz_name)
{
- module_t *p_module = __module_find( p_this, psz_name );
+ module_t *p_module = module_find (psz_name);
if( p_module )
module_release (p_module);
return p_module != NULL;
* 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 )
{
size_t count = 0;
char **psz_ret;
if( !psz_ret || ( pppsz_longname && *pppsz_longname == NULL ) )
{
free( psz_ret );
- free( *pppsz_longname );
- *pppsz_longname = NULL;
+ if( pppsz_longname )
+ {
+ free( *pppsz_longname );
+ *pppsz_longname = NULL;
+ }
module_list_free (list);
return NULL;
}
return path;
}
-extern char *psz_vlcpath = NULL;
+char *psz_vlcpath = NULL;
/*****************************************************************************
* AllocateAllPlugins: load all plugin modules we can find.
* Check our plugins cache first then load plugin if needed
*/
p_cache_entry =
- CacheFind( psz_file, i_file_time, i_file_size );
+ CacheFind( p_module_bank, psz_file, i_file_time, i_file_size );
if( !p_cache_entry )
{
*****************************************************************************
* This function can only be called if the module isn't being used.
*****************************************************************************/
-static void DeleteModule( module_t * p_module )
+static void DeleteModule( module_bank_t *p_bank, module_t * p_module )
{
assert( p_module );
/* Unlist the module (if it is in the list) */
- module_t **pp_self = &p_module_bank->head;
+ module_t **pp_self = &p_bank->head;
while (*pp_self != NULL && *pp_self != p_module)
pp_self = &((*pp_self)->next);
if (*pp_self)
projects / vlc / blobdiff