remap: Make resampler's remap structure more self-contained

[pulseaudio] / src / pulsecore / module.c

diff --git a/src/pulsecore/module.c b/src/pulsecore/module.c
index f1eeb7622c7036835b921b625418b0a14efd4293..bee8a20efbed43ecd7fb07541b691023f4b02194 100644 (file)
--- a/src/pulsecore/module.c
+++ b/src/pulsecore/module.c
@@ -6,7 +6,7 @@
 
   PulseAudio is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
 
   PulseAudio is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published

-  by the Free Software Foundation; either version 2 of the License,
+  by the Free Software Foundation; either version 2.1 of the License,

   or (at your option) any later version.
 
   PulseAudio is distributed in the hope that it will be useful, but
   or (at your option) any later version.
 
   PulseAudio is distributed in the hope that it will be useful, but


@@ -24,48 +24,89 @@
 #include <config.h>
 #endif
 
 #include <config.h>
 #endif
 

-#include <limits.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>

-#include <ctype.h>
+#include <ltdl.h>

 
 

-#include <pulse/timeval.h>

 #include <pulse/xmalloc.h>
 #include <pulse/xmalloc.h>

+#include <pulse/proplist.h>

 
 #include <pulsecore/core-subscribe.h>
 #include <pulsecore/log.h>
 #include <pulsecore/core-util.h>
 #include <pulsecore/macro.h>
 #include <pulsecore/ltdl-helper.h>
 
 #include <pulsecore/core-subscribe.h>
 #include <pulsecore/log.h>
 #include <pulsecore/core-util.h>
 #include <pulsecore/macro.h>
 #include <pulsecore/ltdl-helper.h>

+#include <pulsecore/modinfo.h>

 
 #include "module.h"
 
 #define PA_SYMBOL_INIT "pa__init"
 #define PA_SYMBOL_DONE "pa__done"
 #define PA_SYMBOL_LOAD_ONCE "pa__load_once"
 
 #include "module.h"
 
 #define PA_SYMBOL_INIT "pa__init"
 #define PA_SYMBOL_DONE "pa__done"
 #define PA_SYMBOL_LOAD_ONCE "pa__load_once"

+#define PA_SYMBOL_GET_N_USED "pa__get_n_used"
+#define PA_SYMBOL_GET_DEPRECATE "pa__get_deprecated"

 
 

-#define UNLOAD_POLL_TIME 2
+bool pa_module_exists(const char *name) {
+    const char *paths, *state = NULL;
+    char *n, *p, *pathname;
+    bool result;

 
 

-static void timeout_callback(pa_mainloop_api *m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
-    pa_core *c = PA_CORE(userdata);
-    struct timeval ntv;
+    pa_assert(name);

 
 

-    pa_core_assert_ref(c);
-    pa_assert(c->mainloop == m);
-    pa_assert(c->module_auto_unload_event == e);
+    if (name[0] == PA_PATH_SEP_CHAR) {
+        result = access(name, F_OK) == 0 ? true : false;
+        pa_log_debug("Checking for existence of '%s': %s", name, result ? "success" : "failure");
+        if (result)
+            return true;
+    }
+
+    if (!(paths = lt_dlgetsearchpath()))
+        return false;
+
+    /* strip .so from the end of name, if present */
+    n = pa_xstrdup(name);
+    p = strrchr(n, '.');
+    if (p && pa_streq(p, PA_SOEXT))
+        p[0] = 0;
+
+    while ((p = pa_split(paths, ":", &state))) {
+        pathname = pa_sprintf_malloc("%s" PA_PATH_SEP "%s" PA_SOEXT, p, n);
+        result = access(pathname, F_OK) == 0 ? true : false;
+        pa_log_debug("Checking for existence of '%s': %s", pathname, result ? "success" : "failure");
+        pa_xfree(pathname);
+        pa_xfree(p);
+        if (result) {
+            pa_xfree(n);
+            return true;
+        }
+    }

 
 

-    pa_module_unload_unused(c);
+    state = NULL;
+    if (PA_UNLIKELY(pa_run_from_build_tree())) {
+        while ((p = pa_split(paths, ":", &state))) {
+            pathname = pa_sprintf_malloc("%s" PA_PATH_SEP ".libs" PA_PATH_SEP "%s" PA_SOEXT, p, n);
+            result = access(pathname, F_OK) == 0 ? true : false;
+            pa_log_debug("Checking for existence of '%s': %s", pathname, result ? "success" : "failure");
+            pa_xfree(pathname);
+            pa_xfree(p);
+            if (result) {
+                pa_xfree(n);
+                return true;
+            }
+        }
+    }

 
 

-    pa_gettimeofday(&ntv);
-    pa_timeval_add(&ntv, UNLOAD_POLL_TIME*1000000);
-    m->time_restart(e, &ntv);
+    pa_xfree(n);
+    return false;

 }
 
 pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
     pa_module *m = NULL;
 }
 
 pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
     pa_module *m = NULL;

-    pa_bool_t (*load_once)(void);
+    bool (*load_once)(void);
+    const char* (*get_deprecated)(void);
+    pa_modinfo *mi;

 
     pa_assert(c);
     pa_assert(name);
 
     pa_assert(c);
     pa_assert(name);


@@ -76,21 +117,32 @@ pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
     m = pa_xnew(pa_module, 1);
     m->name = pa_xstrdup(name);
     m->argument = pa_xstrdup(argument);
     m = pa_xnew(pa_module, 1);
     m->name = pa_xstrdup(name);
     m->argument = pa_xstrdup(argument);

+    m->load_once = false;
+    m->proplist = pa_proplist_new();
+    m->index = PA_IDXSET_INVALID;

 
     if (!(m->dl = lt_dlopenext(name))) {
 
     if (!(m->dl = lt_dlopenext(name))) {

-        pa_log("Failed to open module \"%s\": %s", name, lt_dlerror());
+        /* We used to print the error that is returned by lt_dlerror(), but
+         * lt_dlerror() is useless. It returns pretty much always "file not
+         * found". That's because if there are any problems with loading the
+         * module with normal loaders, libltdl falls back to the "preload"
+         * loader, which never finds anything, and therefore says "file not
+         * found". */
+        pa_log("Failed to open module \"%s\".", name);

         goto fail;
     }
 
         goto fail;
     }
 

-    if ((load_once = (pa_bool_t (*)(void)) pa_load_sym(m->dl, name, PA_SYMBOL_LOAD_ONCE))) {
+    if ((load_once = (bool (*)(void)) pa_load_sym(m->dl, name, PA_SYMBOL_LOAD_ONCE))) {

 
 

-        if (load_once() && c->modules) {
+        m->load_once = load_once();
+
+        if (m->load_once) {

             pa_module *i;
             uint32_t idx;
             /* OK, the module only wants to be loaded once, let's make sure it is */
 
             pa_module *i;
             uint32_t idx;
             /* OK, the module only wants to be loaded once, let's make sure it is */
 

-            for (i = pa_idxset_first(c->modules, &idx); i; i = pa_idxset_next(c->modules, &idx)) {
-                if (strcmp(name, i->name) == 0) {
+            PA_IDXSET_FOREACH(i, c->modules, idx) {
+                if (pa_streq(name, i->name)) {

                     pa_log("Module \"%s\" should be loaded once at most. Refusing to load.", name);
                     goto fail;
                 }
                     pa_log("Module \"%s\" should be loaded once at most. Refusing to load.", name);
                     goto fail;
                 }


@@ -98,45 +150,61 @@ pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
         }
     }
 
         }
     }
 

+    if ((get_deprecated = (const char* (*) (void)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_DEPRECATE))) {
+        const char *t;
+
+        if ((t = get_deprecated()))
+            pa_log_warn("%s is deprecated: %s", name, t);
+    }
+

     if (!(m->init = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_INIT))) {
         pa_log("Failed to load module \"%s\": symbol \""PA_SYMBOL_INIT"\" not found.", name);
         goto fail;
     }
 
     m->done = (void (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_DONE);
     if (!(m->init = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_INIT))) {
         pa_log("Failed to load module \"%s\": symbol \""PA_SYMBOL_INIT"\" not found.", name);
         goto fail;
     }
 
     m->done = (void (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_DONE);

+    m->get_n_used = (int (*)(pa_module*_m)) pa_load_sym(m->dl, name, PA_SYMBOL_GET_N_USED);

     m->userdata = NULL;
     m->core = c;
     m->userdata = NULL;
     m->core = c;

-    m->n_used = -1;
-    m->auto_unload = FALSE;
-    m->unload_requested = FALSE;
+    m->unload_requested = false;
+
+    pa_assert_se(pa_idxset_put(c->modules, m, &m->index) >= 0);
+    pa_assert(m->index != PA_IDXSET_INVALID);

 
     if (m->init(m) < 0) {
 
     if (m->init(m) < 0) {

-        pa_log_error("Failed to load  module \"%s\" (argument: \"%s\"): initialization failed.", name, argument ? argument : "");
+        pa_log_error("Failed to load module \"%s\" (argument: \"%s\"): initialization failed.", name, argument ? argument : "");

         goto fail;
     }
 
         goto fail;
     }
 

-    if (!c->modules)
-        c->modules = pa_idxset_new(NULL, NULL);
+    pa_log_info("Loaded \"%s\" (index: #%u; argument: \"%s\").", m->name, m->index, m->argument ? m->argument : "");

 
 

-    if (m->auto_unload && !c->module_auto_unload_event) {
-        struct timeval ntv;
-        pa_gettimeofday(&ntv);
-        pa_timeval_add(&ntv, UNLOAD_POLL_TIME*1000000);
-        c->module_auto_unload_event = c->mainloop->time_new(c->mainloop, &ntv, timeout_callback, c);
-    }
+    pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_NEW, m->index);

 
 

-    pa_assert_se(pa_idxset_put(c->modules, m, &m->index) >= 0);
-    pa_assert(m->index != PA_IDXSET_INVALID);
+    if ((mi = pa_modinfo_get_by_handle(m->dl, name))) {

 
 

-    pa_log_info("Loaded \"%s\" (index: #%u; argument: \"%s\").", m->name, m->index, m->argument ? m->argument : "");
+        if (mi->author && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_AUTHOR))
+            pa_proplist_sets(m->proplist, PA_PROP_MODULE_AUTHOR, mi->author);

 
 

-    pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_NEW, m->index);
+        if (mi->description && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_DESCRIPTION))
+            pa_proplist_sets(m->proplist, PA_PROP_MODULE_DESCRIPTION, mi->description);
+
+        if (mi->version && !pa_proplist_contains(m->proplist, PA_PROP_MODULE_VERSION))
+            pa_proplist_sets(m->proplist, PA_PROP_MODULE_VERSION, mi->version);
+
+        pa_modinfo_free(mi);
+    }

 
     return m;
 
 fail:
 
     if (m) {
 
     return m;
 
 fail:
 
     if (m) {

+        if (m->index != PA_IDXSET_INVALID)
+            pa_idxset_remove_by_index(c->modules, m->index);
+
+        if (m->proplist)
+            pa_proplist_free(m->proplist);
+

         pa_xfree(m->argument);
         pa_xfree(m->name);
 
         pa_xfree(m->argument);
         pa_xfree(m->name);
 


@@ -153,14 +221,14 @@ static void pa_module_free(pa_module *m) {
     pa_assert(m);
     pa_assert(m->core);
 
     pa_assert(m);
     pa_assert(m->core);
 

-    if (m->core->disallow_module_loading)
-        return;
-

     pa_log_info("Unloading \"%s\" (index: #%u).", m->name, m->index);
 
     if (m->done)
         m->done(m);
 
     pa_log_info("Unloading \"%s\" (index: #%u).", m->name, m->index);
 
     if (m->done)
         m->done(m);
 

+    if (m->proplist)
+        pa_proplist_free(m->proplist);
+

     lt_dlclose(m->dl);
 
     pa_log_info("Unloaded \"%s\" (index: #%u).", m->name, m->index);
     lt_dlclose(m->dl);
 
     pa_log_info("Unloaded \"%s\" (index: #%u).", m->name, m->index);


@@ -172,52 +240,61 @@ static void pa_module_free(pa_module *m) {
     pa_xfree(m);
 }
 
     pa_xfree(m);
 }
 

-void pa_module_unload(pa_core *c, pa_module *m) {
+void pa_module_unload(pa_core *c, pa_module *m, bool force) {

     pa_assert(c);
     pa_assert(m);
 
     pa_assert(c);
     pa_assert(m);
 

-    pa_assert(c->modules);
+    if (m->core->disallow_module_loading && !force)
+        return;
+

     if (!(m = pa_idxset_remove_by_data(c->modules, m, NULL)))
         return;
 
     pa_module_free(m);
 }
 
     if (!(m = pa_idxset_remove_by_data(c->modules, m, NULL)))
         return;
 
     pa_module_free(m);
 }
 

-void pa_module_unload_by_index(pa_core *c, uint32_t idx) {
+void pa_module_unload_by_index(pa_core *c, uint32_t idx, bool force) {

     pa_module *m;
     pa_assert(c);
     pa_assert(idx != PA_IDXSET_INVALID);
 
     pa_module *m;
     pa_assert(c);
     pa_assert(idx != PA_IDXSET_INVALID);
 

-    if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
+    if (c->disallow_module_loading && !force)

         return;
 
         return;
 

-    pa_module_free(m);
-}
+    if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
+        return;

 
 

-static void free_callback(void *p, PA_GCC_UNUSED void *userdata) {
-    pa_module *m = p;
-    pa_assert(m);

     pa_module_free(m);
 }
 
 void pa_module_unload_all(pa_core *c) {
     pa_module *m;
     pa_module_free(m);
 }
 
 void pa_module_unload_all(pa_core *c) {
     pa_module *m;

+    uint32_t *indices;
+    uint32_t state;
+    int i;

 
     pa_assert(c);
 
     pa_assert(c);

+    pa_assert(c->modules);

 
 

-    if (!c->modules)
+    if (pa_idxset_isempty(c->modules))

         return;
 
         return;
 

-    while ((m = pa_idxset_first(c->modules, NULL)))
-        pa_module_unload(c, m);
-
-    pa_idxset_free(c->modules, free_callback, NULL);
-    c->modules = NULL;
-
-    if (c->module_auto_unload_event) {
-        c->mainloop->time_free(c->module_auto_unload_event);
-        c->module_auto_unload_event = NULL;
+    /* Unload modules in reverse order by default */
+    indices = pa_xnew(uint32_t, pa_idxset_size(c->modules));
+    i = 0;
+    PA_IDXSET_FOREACH(m, c->modules, state)
+        indices[i++] = state;
+    pa_assert(i == (int) pa_idxset_size(c->modules));
+    i--;
+    for (; i >= 0; i--) {
+        m = pa_idxset_remove_by_index(c->modules, indices[i]);
+        if (m)
+            pa_module_free(m);

     }
     }

+    pa_xfree(indices);
+
+    /* Just in case module unloading caused more modules to load */
+    pa_idxset_remove_all(c->modules, (pa_free_cb_t) pa_module_free);

 
     if (c->module_defer_unload_event) {
         c->mainloop->defer_free(c->module_defer_unload_event);
 
     if (c->module_defer_unload_event) {
         c->mainloop->defer_free(c->module_defer_unload_event);


@@ -225,82 +302,57 @@ void pa_module_unload_all(pa_core *c) {
     }
 }
 
     }
 }
 

-static int unused_callback(void *p, PA_GCC_UNUSED uint32_t idx, int *del, void *userdata) {
-    pa_module *m = p;
-    time_t *now = userdata;
-
-    pa_assert(m);
-    pa_assert(del);
-    pa_assert(now);
+static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
+    void *state = NULL;
+    pa_core *c = PA_CORE(userdata);
+    pa_module *m;

 
 

-    if (m->n_used == 0 && m->auto_unload && m->last_used_time+m->core->module_idle_time <= *now) {
-        pa_module_free(m);
-        *del = 1;
-    }
+    pa_core_assert_ref(c);
+    api->defer_enable(e, 0);

 
 

-    return 0;
+    while ((m = pa_idxset_iterate(c->modules, &state, NULL)))
+        if (m->unload_requested)
+            pa_module_unload(c, m, true);

 }
 
 }
 

-void pa_module_unload_unused(pa_core *c) {
-    time_t now;
-    pa_assert(c);
+void pa_module_unload_request(pa_module *m, bool force) {
+    pa_assert(m);

 
 

-    if (!c->modules)
+    if (m->core->disallow_module_loading && !force)

         return;
 
         return;
 

-    time(&now);
-    pa_idxset_foreach(c->modules, unused_callback, &now);
-}
-
-static int unload_callback(void *p, PA_GCC_UNUSED uint32_t idx, int *del, PA_GCC_UNUSED void *userdata) {
-    pa_module *m = p;
-    pa_assert(m);
+    m->unload_requested = true;

 
 

-    if (m->unload_requested) {
-        pa_module_free(m);
-        *del = 1;
-    }
+    if (!m->core->module_defer_unload_event)
+        m->core->module_defer_unload_event = m->core->mainloop->defer_new(m->core->mainloop, defer_cb, m->core);

 
 

-    return 0;
+    m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);

 }
 
 }
 

-static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
-    pa_core *core = PA_CORE(userdata);
-
-    pa_core_assert_ref(core);
-    api->defer_enable(e, 0);
+void pa_module_unload_request_by_index(pa_core *c, uint32_t idx, bool force) {
+    pa_module *m;
+    pa_assert(c);

 
 

-    if (!core->modules)
+    if (!(m = pa_idxset_get_by_index(c->modules, idx)))

         return;
 
         return;
 

-    pa_idxset_foreach(core->modules, unload_callback, NULL);
+    pa_module_unload_request(m, force);

 }
 
 }
 

-void pa_module_unload_request(pa_module *m) {
+int pa_module_get_n_used(pa_module*m) {

     pa_assert(m);
 
     pa_assert(m);
 

-    m->unload_requested = TRUE;
+    if (!m->get_n_used)
+        return -1;

 
 

-    if (!m->core->module_defer_unload_event)
-        m->core->module_defer_unload_event = m->core->mainloop->defer_new(m->core->mainloop, defer_cb, m->core);
-
-    m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);
+    return m->get_n_used(m);

 }
 
 }
 

-void pa_module_set_used(pa_module*m, int used) {
+void pa_module_update_proplist(pa_module *m, pa_update_mode_t mode, pa_proplist *p) {

     pa_assert(m);
 
     pa_assert(m);
 

-    if (m->n_used != used)
-        pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_CHANGE, m->index);
-
-    if (used == 0 && m->n_used > 0)
-        time(&m->last_used_time);
-
-    m->n_used = used;
-}
-
-pa_modinfo *pa_module_get_info(pa_module *m) {
-    pa_assert(m);
+    if (p)
+        pa_proplist_update(m->proplist, mode, p);

 
 

-    return pa_modinfo_get_by_handle(m->dl, m->name);
+    pa_subscription_post(m->core, PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_CHANGE, m->index);

 }
 }