[pulseaudio-discuss] [PATCH 1/2] ladspa: D-Bus interface for setting algorithm parameters on-the-fly.
ismo.puustinen at intel.com
ismo.puustinen at intel.com
Fri Jun 15 07:35:58 PDT 2012
From: Ismo Puustinen <ismo.puustinen at intel.com>
A new external D-Bus interface is registered and LADSPA algorithm
control parameters are exposed as a D-Bus property with setter and
getter support.
---
src/Makefile.am | 5 +
src/modules/module-ladspa-sink.c | 680 ++++++++++++++++++++++++++++++--------
2 files changed, 541 insertions(+), 144 deletions(-)
diff --git a/src/Makefile.am b/src/Makefile.am
index 127956a..6ebaeb0 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1524,6 +1524,11 @@ module_ladspa_sink_la_CFLAGS = -DLADSPA_PATH=\"$(libdir)/ladspa:/usr/local/lib/l
module_ladspa_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
module_ladspa_sink_la_LIBADD = $(MODULE_LIBADD) $(LIBLTDL)
+if HAVE_DBUS
+module_ladspa_sink_la_CFLAGS += $(DBUS_CFLAGS)
+module_ladspa_sink_la_LIBADD += $(DBUS_LIBS)
+endif
+
module_equalizer_sink_la_SOURCES = modules/module-equalizer-sink.c
module_equalizer_sink_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS) $(DBUS_CFLAGS) $(FFTW_CFLAGS)
module_equalizer_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
diff --git a/src/modules/module-ladspa-sink.c b/src/modules/module-ladspa-sink.c
index 500f8f6..a523497 100644
--- a/src/modules/module-ladspa-sink.c
+++ b/src/modules/module-ladspa-sink.c
@@ -41,6 +41,11 @@
#include <pulsecore/sample-util.h>
#include <pulsecore/ltdl-helper.h>
+#ifdef HAVE_DBUS
+#include <pulsecore/protocol-dbus.h>
+#include <pulsecore/dbus-util.h>
+#endif
+
#include "module-ladspa-sink-symdef.h"
#include "ladspa.h"
@@ -79,6 +84,7 @@ struct userdata {
LADSPA_Data **input, **output;
size_t block_size;
LADSPA_Data *control;
+ long unsigned n_control;
/* This is a dummy buffer. Every port must be connected, but we don't care
about control out ports. We connect them all to this single buffer. */
@@ -86,6 +92,14 @@ struct userdata {
pa_memblockq *memblockq;
+ pa_bool_t *use_default;
+ pa_sample_spec ss;
+
+#ifdef HAVE_DBUS
+ pa_dbus_protocol *dbus_protocol;
+ char *dbus_path;
+#endif
+
pa_bool_t auto_desc;
};
@@ -105,6 +119,218 @@ static const char* const valid_modargs[] = {
NULL
};
+/* The PA_SINK_MESSAGE types that extend the predefined messages. */
+enum {
+ LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS = PA_SINK_MESSAGE_MAX
+};
+
+static int write_control_parameters(struct userdata *u, double *control_values, pa_bool_t *use_default);
+static void connect_control_ports(struct userdata *u);
+
+#ifdef HAVE_DBUS
+
+#define LADSPA_IFACE "org.PulseAudio.Ext.Ladspa1"
+#define LADSPA_ALGORITHM_PARAMETERS "AlgorithmParameters"
+
+/* TODO: add a PropertyChanged signal to tell that the algorithm parameters have been changed */
+
+enum ladspa_handler_index {
+ LADSPA_HANDLER_ALGORITHM_PARAMETERS,
+ LADSPA_HANDLER_MAX
+};
+
+static void get_algorithm_parameters(DBusConnection *conn, DBusMessage *msg, void *_u) {
+ struct userdata *u;
+ DBusMessage *reply = NULL;
+ DBusMessageIter msg_iter, struct_iter;
+ unsigned long i;
+ double *control;
+ dbus_bool_t *use_default;
+
+ pa_assert(conn);
+ pa_assert(msg);
+ pa_assert_se(u = _u);
+
+ pa_assert_se((reply = dbus_message_new_method_return(msg)));
+ dbus_message_iter_init_append(reply, &msg_iter);
+
+ dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter);
+
+ /* copying because of the D-Bus type mapping */
+ control = pa_xnew(double, u->n_control);
+ use_default = pa_xnew(dbus_bool_t, u->n_control);
+
+ for (i = 0; i < u->n_control; i++) {
+ control[i] = (double) u->control[i];
+ use_default[i] = u->use_default[i];
+ }
+
+ pa_dbus_append_basic_array(&struct_iter, DBUS_TYPE_DOUBLE, control, u->n_control);
+ pa_dbus_append_basic_array(&struct_iter, DBUS_TYPE_BOOLEAN, use_default, u->n_control);
+
+ dbus_message_iter_close_container(&msg_iter, &struct_iter);
+
+ pa_assert_se(dbus_connection_send(conn, reply, NULL));
+
+ dbus_message_unref(reply);
+ pa_xfree(control);
+ pa_xfree(use_default);
+}
+
+static void set_algorithm_parameters(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *_u) {
+ struct userdata *u;
+ DBusMessageIter array_iter, struct_iter;
+ int n_control = 0, n_use_default;
+ unsigned n_dbus_control, n_dbus_use_default;
+ double *read_values = NULL;
+ dbus_bool_t *read_defaults = NULL;
+ pa_bool_t *use_defaults = NULL;
+ unsigned long i;
+
+ pa_assert(conn);
+ pa_assert(msg);
+ pa_assert_se(u = _u);
+
+ /* The property we are expecting has signature (adab), meaning that it's a
+ struct of two arrays, the first containing doubles and the second containing
+ booleans. The first array has the algorithm configuration values and the
+ second array has booleans indicating whether the matching algorithm
+ configuration value should use (or try to use) the default value provided by
+ the algorithm module. The PulseAudio D-Bus infrastructure will take care of
+ checking the argument types for us. */
+
+ dbus_message_iter_recurse(iter, &struct_iter);
+
+ dbus_message_iter_recurse(&struct_iter, &array_iter);
+ dbus_message_iter_get_fixed_array(&array_iter, &read_values, &n_control);
+
+ dbus_message_iter_next(&struct_iter);
+ dbus_message_iter_recurse(&struct_iter, &array_iter);
+ dbus_message_iter_get_fixed_array(&array_iter, &read_defaults, &n_use_default);
+
+ n_dbus_control = n_control; /* handle the unsignedness */
+ n_dbus_use_default = n_use_default;
+
+ if (n_dbus_control != u->n_control || n_dbus_use_default != u->n_control) {
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong number of array values (expected %lu)", u->n_control);
+ return;
+ }
+
+ use_defaults = pa_xnew(pa_bool_t, n_control);
+ for (i = 0; i < u->n_control; i++)
+ use_defaults[i] = read_defaults[i];
+
+ if (write_control_parameters(u, read_values, use_defaults) < 0) {
+ pa_log_warn("Failed writing control parameters");
+ goto error;
+ }
+
+ pa_asyncmsgq_send(u->sink->asyncmsgq, PA_MSGOBJECT(u->sink), LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS, NULL, 0, NULL);
+
+ pa_dbus_send_empty_reply(conn, msg);
+
+ pa_xfree(use_defaults);
+ return;
+
+error:
+ pa_xfree(use_defaults);
+ pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Internal error");
+}
+
+static pa_dbus_property_handler ladspa_property_handlers[LADSPA_HANDLER_MAX] = {
+ [LADSPA_HANDLER_ALGORITHM_PARAMETERS] = {
+ .property_name = LADSPA_ALGORITHM_PARAMETERS,
+ .type = "(adab)",
+ .get_cb = get_algorithm_parameters,
+ .set_cb = set_algorithm_parameters
+ }
+};
+
+static void ladspa_get_all(DBusConnection *conn, DBusMessage *msg, void *_u) {
+ struct userdata *u;
+ DBusMessage *reply = NULL;
+ DBusMessageIter msg_iter, dict_iter, dict_entry_iter, variant_iter, struct_iter;
+ const char *key = LADSPA_ALGORITHM_PARAMETERS;
+ double *control;
+ dbus_bool_t *use_default;
+ long unsigned i;
+
+ pa_assert(conn);
+ pa_assert(msg);
+ pa_assert_se(u = _u);
+
+ pa_assert_se((reply = dbus_message_new_method_return(msg)));
+
+ /* Currently, on this interface, only a single property is returned. */
+
+ dbus_message_iter_init_append(reply, &msg_iter);
+ pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
+ pa_assert_se(dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter));
+ pa_assert_se(dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, &key));
+
+ pa_assert_se(dbus_message_iter_open_container(&dict_entry_iter, DBUS_TYPE_VARIANT, "(adab)", &variant_iter));
+ pa_assert_se(dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter));
+
+ control = pa_xnew(double, u->n_control);
+ use_default = pa_xnew(dbus_bool_t, u->n_control);
+
+ for (i = 0; i < u->n_control; i++) {
+ control[i] = (double) u->control[i];
+ use_default[i] = u->use_default[i];
+ }
+
+ pa_dbus_append_basic_array(&struct_iter, DBUS_TYPE_DOUBLE, control, u->n_control);
+ pa_dbus_append_basic_array(&struct_iter, DBUS_TYPE_BOOLEAN, use_default, u->n_control);
+
+ pa_assert_se(dbus_message_iter_close_container(&variant_iter, &struct_iter));
+ pa_assert_se(dbus_message_iter_close_container(&dict_entry_iter, &variant_iter));
+ pa_assert_se(dbus_message_iter_close_container(&dict_iter, &dict_entry_iter));
+ pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
+
+ pa_assert_se(dbus_connection_send(conn, reply, NULL));
+ dbus_message_unref(reply);
+ pa_xfree(control);
+ pa_xfree(use_default);
+}
+
+static pa_dbus_interface_info ladspa_info={
+ .name = LADSPA_IFACE,
+ .method_handlers = NULL,
+ .n_method_handlers = 0,
+ .property_handlers = ladspa_property_handlers,
+ .n_property_handlers = LADSPA_HANDLER_MAX,
+ .get_all_properties_cb = ladspa_get_all,
+ .signals = NULL,
+ .n_signals = 0
+};
+
+static void dbus_init(struct userdata *u) {
+ pa_assert_se(u);
+
+ u->dbus_protocol = pa_dbus_protocol_get(u->sink->core);
+ u->dbus_path = pa_sprintf_malloc("/org/pulseaudio/core1/sink%d", u->sink->index);
+
+ pa_dbus_protocol_add_interface(u->dbus_protocol, u->dbus_path, &ladspa_info, u);
+}
+
+static void dbus_done(struct userdata *u) {
+ pa_assert_se(u);
+
+ if (!u->dbus_protocol) {
+ pa_assert(!u->dbus_path);
+ return;
+ }
+
+ pa_dbus_protocol_remove_interface(u->dbus_protocol, u->dbus_path, ladspa_info.name);
+ pa_xfree(u->dbus_path);
+ pa_dbus_protocol_unref(u->dbus_protocol);
+
+ u->dbus_path = NULL;
+ u->dbus_protocol = NULL;
+}
+
+#endif /* HAVE_DBUS */
+
/* Called from I/O thread context */
static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
struct userdata *u = PA_SINK(o)->userdata;
@@ -131,6 +357,18 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
return 0;
+
+ case LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS:
+
+ /* rewind the stream to throw away the previously rendered data */
+
+ pa_log_debug("Requesting rewind due to parameter update.");
+ pa_sink_request_rewind(u->sink, -1);
+
+ /* change the sink parameters */
+ connect_control_ports(u);
+
+ return 0;
}
return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -469,6 +707,276 @@ static void sink_input_mute_changed_cb(pa_sink_input *i) {
pa_sink_mute_changed(u->sink, i->muted);
}
+static int parse_control_parameters(struct userdata *u, const char *cdata, double *read_values, pa_bool_t *use_default) {
+
+ unsigned long p = 0;
+ const char *state = NULL;
+ char *k;
+
+ pa_assert(read_values);
+ pa_assert(use_default);
+ pa_assert(u);
+
+ pa_log_debug("Trying to read %lu control values", u->n_control);
+
+ if (!cdata && u->n_control > 0)
+ return -1;
+
+ pa_log_debug("cdata: '%s'", cdata);
+
+ while ((k = pa_split(cdata, ",", &state)) && p < u->n_control) {
+ double f;
+
+ if (*k == 0) {
+ pa_log_debug("Read empty config value (p=%lu)", p);
+ use_default[p++] = TRUE;
+ pa_xfree(k);
+ continue;
+ }
+
+ if (pa_atod(k, &f) < 0) {
+ pa_log_debug("Failed to parse control value '%s' (p=%lu)", k, p);
+ pa_xfree(k);
+ goto fail;
+ }
+
+ pa_xfree(k);
+
+ pa_log_debug("Read config value %f (p=%lu)", f, p);
+
+ use_default[p] = FALSE;
+ read_values[p++] = f;
+ }
+
+ /* The previous loop doesn't take the last control value into account
+ if it is left empty, so we do it here. */
+ if (*cdata == 0 || cdata[strlen(cdata) - 1] == ',') {
+ if (p < u->n_control)
+ use_default[p] = TRUE;
+ p++;
+ }
+
+ if (p > u->n_control || k) {
+ pa_log("Too many control values passed, %lu expected.", u->n_control);
+ pa_xfree(k);
+ goto fail;
+ }
+
+ if (p < u->n_control) {
+ pa_log("Not enough control values passed, %lu expected, %lu passed.", u->n_control, p);
+ goto fail;
+ }
+
+ return 0;
+
+fail:
+ return -1;
+}
+
+static void connect_control_ports(struct userdata *u) {
+ unsigned long p = 0, h = 0, c;
+ const LADSPA_Descriptor *d;
+
+ pa_assert(u);
+ pa_assert_se(d = u->descriptor);
+
+ for (p = 0; p < d->PortCount; p++) {
+ if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
+ continue;
+
+ if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p])) {
+ for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
+ d->connect_port(u->handle[c], p, &u->control_out);
+ continue;
+ }
+
+ /* input control port */
+
+ pa_log_debug("Binding %f to port %s", u->control[h], d->PortNames[p]);
+
+ for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
+ d->connect_port(u->handle[c], p, &u->control[h]);
+
+ h++;
+ }
+}
+
+static int validate_control_parameters(struct userdata *u, double *control_values, pa_bool_t *use_default) {
+ unsigned long p = 0, h = 0;
+ const LADSPA_Descriptor *d;
+ pa_sample_spec ss;
+
+ pa_assert(control_values);
+ pa_assert(use_default);
+ pa_assert(u);
+ ss = u->ss;
+ d = u->descriptor;
+ pa_assert(d);
+
+ /* Iterate over all ports. Check for every control port that 1) it
+ * supports default values if a default value is provided and 2) the
+ * provided value is within the limits specified in the plugin. */
+
+ for (p = 0; p < d->PortCount; p++) {
+ LADSPA_PortRangeHintDescriptor hint = d->PortRangeHints[p].HintDescriptor;
+
+ if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
+ continue;
+
+ if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p]))
+ continue;
+
+ if (use_default[h]) {
+ /* User wants to use default value. Check if the plugin
+ * provides it. */
+ if (!LADSPA_IS_HINT_HAS_DEFAULT(hint)) {
+ pa_log_warn("Control port value left empty but plugin defines no default.");
+ return -1;
+ }
+ }
+ else {
+ /* Check if the user-provided value is within the bounds. */
+ LADSPA_Data lower = d->PortRangeHints[p].LowerBound;
+ LADSPA_Data upper = d->PortRangeHints[p].UpperBound;
+
+ if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) {
+ upper *= (LADSPA_Data) ss.rate;
+ lower *= (LADSPA_Data) ss.rate;
+ }
+
+ if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint)) {
+ if (control_values[h] > upper) {
+ pa_log_warn("Control value %lu over upper bound: %f / %f", h, control_values[h], upper);
+ return -1;
+ }
+ }
+ if (LADSPA_IS_HINT_BOUNDED_BELOW(hint)) {
+ if (control_values[h] < lower) {
+ pa_log_warn("Control value below lower bound: %f / %f", control_values[h], lower);
+ return -1;
+ }
+ }
+ }
+
+ h++;
+ }
+
+ return 0;
+}
+
+static int write_control_parameters(struct userdata *u, double *control_values, pa_bool_t *use_default) {
+ unsigned long p = 0, h = 0, c;
+ const LADSPA_Descriptor *d;
+ pa_sample_spec ss;
+
+ pa_assert(control_values);
+ pa_assert(use_default);
+ pa_assert(u);
+ ss = u->ss;
+ d = u->descriptor;
+ pa_assert(d);
+
+ if (validate_control_parameters(u, control_values, use_default) < 0) {
+ return -1;
+ }
+
+ /* p iterates over all ports, h is the control port iterator */
+
+ for (p = 0; p < d->PortCount; p++) {
+ LADSPA_PortRangeHintDescriptor hint = d->PortRangeHints[p].HintDescriptor;
+
+ if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
+ continue;
+
+ if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p])) {
+ for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
+ d->connect_port(u->handle[c], p, &u->control_out);
+ continue;
+ }
+
+ if (use_default[h]) {
+
+ LADSPA_Data lower, upper;
+
+ lower = d->PortRangeHints[p].LowerBound;
+ upper = d->PortRangeHints[p].UpperBound;
+
+ if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) {
+ lower *= (LADSPA_Data) ss.rate;
+ upper *= (LADSPA_Data) ss.rate;
+ }
+
+ switch (hint & LADSPA_HINT_DEFAULT_MASK) {
+
+ case LADSPA_HINT_DEFAULT_MINIMUM:
+ u->control[h] = lower;
+ break;
+
+ case LADSPA_HINT_DEFAULT_MAXIMUM:
+ u->control[h] = upper;
+ break;
+
+ case LADSPA_HINT_DEFAULT_LOW:
+ if (LADSPA_IS_HINT_LOGARITHMIC(hint))
+ u->control[h] = (LADSPA_Data) exp(log(lower) * 0.75 + log(upper) * 0.25);
+ else
+ u->control[h] = (LADSPA_Data) (lower * 0.75 + upper * 0.25);
+ break;
+
+ case LADSPA_HINT_DEFAULT_MIDDLE:
+ if (LADSPA_IS_HINT_LOGARITHMIC(hint))
+ u->control[h] = (LADSPA_Data) exp(log(lower) * 0.5 + log(upper) * 0.5);
+ else
+ u->control[h] = (LADSPA_Data) (lower * 0.5 + upper * 0.5);
+ break;
+
+ case LADSPA_HINT_DEFAULT_HIGH:
+ if (LADSPA_IS_HINT_LOGARITHMIC(hint))
+ u->control[h] = (LADSPA_Data) exp(log(lower) * 0.25 + log(upper) * 0.75);
+ else
+ u->control[h] = (LADSPA_Data) (lower * 0.25 + upper * 0.75);
+ break;
+
+ case LADSPA_HINT_DEFAULT_0:
+ u->control[h] = 0;
+ break;
+
+ case LADSPA_HINT_DEFAULT_1:
+ u->control[h] = 1;
+ break;
+
+ case LADSPA_HINT_DEFAULT_100:
+ u->control[h] = 100;
+ break;
+
+ case LADSPA_HINT_DEFAULT_440:
+ u->control[h] = 440;
+ break;
+
+ default:
+ pa_assert_not_reached();
+ }
+ }
+ else {
+ if (LADSPA_IS_HINT_INTEGER(hint)) {
+ u->control[h] = roundf(control_values[h]);
+ }
+ else {
+ u->control[h] = control_values[h];
+ }
+ }
+
+ h++;
+ }
+
+ /* set the use_default array to the user data */
+
+ memcpy(u->use_default, use_default, u->n_control * sizeof(pa_bool_t));
+
+ return 0;
+}
+
+
int pa__init(pa_module*m) {
struct userdata *u;
pa_sample_spec ss;
@@ -484,7 +992,6 @@ int pa__init(pa_module*m) {
const char *e, *cdata;
const LADSPA_Descriptor *d;
unsigned long p, h, j, n_control, c;
- pa_bool_t *use_default = NULL;
pa_assert(m);
@@ -534,6 +1041,7 @@ int pa__init(pa_module*m) {
u->channels = 0;
u->input = NULL;
u->output = NULL;
+ u->ss = ss;
if (!(e = getenv("LADSPA_PATH")))
e = LADSPA_PATH;
@@ -698,154 +1206,32 @@ int pa__init(pa_module*m) {
d->connect_port(u->handle[h], output_ladspaport[c], u->output[c]);
}
- if (!cdata && n_control > 0) {
- pa_log("This plugin requires specification of %lu control parameters.", n_control);
- goto fail;
- }
-
- if (n_control > 0) {
- const char *state = NULL;
- char *k;
-
- u->control = pa_xnew(LADSPA_Data, (unsigned) n_control);
- use_default = pa_xnew(pa_bool_t, (unsigned) n_control);
- p = 0;
+ u->n_control = n_control;
- while ((k = pa_split(cdata, ",", &state)) && p < n_control) {
- double f;
-
- if (*k == 0) {
- use_default[p++] = TRUE;
- pa_xfree(k);
- continue;
- }
-
- if (pa_atod(k, &f) < 0) {
- pa_log("Failed to parse control value '%s'", k);
- pa_xfree(k);
- goto fail;
- }
+ if (u->n_control > 0) {
+ double *control_values;
+ pa_bool_t *use_default;
- pa_xfree(k);
+ /* temporary storage for parser */
+ control_values = pa_xnew(double, (unsigned) u->n_control);
+ use_default = pa_xnew(pa_bool_t, (unsigned) u->n_control);
- use_default[p] = FALSE;
- u->control[p++] = (LADSPA_Data) f;
- }
+ /* real storage */
+ u->control = pa_xnew(LADSPA_Data, (unsigned) u->n_control);
+ u->use_default = pa_xnew(pa_bool_t, (unsigned) u->n_control);
- /* The previous loop doesn't take the last control value into account
- if it is left empty, so we do it here. */
- if (*cdata == 0 || cdata[strlen(cdata) - 1] == ',') {
- if (p < n_control)
- use_default[p] = TRUE;
- p++;
- }
+ if ((parse_control_parameters(u, cdata, control_values, use_default) < 0) ||
+ (write_control_parameters(u, control_values, use_default) < 0)) {
+ pa_xfree(control_values);
+ pa_xfree(use_default);
- if (p > n_control || k) {
- pa_log("Too many control values passed, %lu expected.", n_control);
- pa_xfree(k);
- goto fail;
- }
+ pa_log("Failed to parse, validate or set control parameters");
- if (p < n_control) {
- pa_log("Not enough control values passed, %lu expected, %lu passed.", n_control, p);
goto fail;
}
-
- h = 0;
- for (p = 0; p < d->PortCount; p++) {
- LADSPA_PortRangeHintDescriptor hint = d->PortRangeHints[p].HintDescriptor;
-
- if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p]))
- continue;
-
- if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p])) {
- for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
- d->connect_port(u->handle[c], p, &u->control_out);
- continue;
- }
-
- pa_assert(h < n_control);
-
- if (use_default[h]) {
- LADSPA_Data lower, upper;
-
- if (!LADSPA_IS_HINT_HAS_DEFAULT(hint)) {
- pa_log("Control port value left empty but plugin defines no default.");
- goto fail;
- }
-
- lower = d->PortRangeHints[p].LowerBound;
- upper = d->PortRangeHints[p].UpperBound;
-
- if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) {
- lower *= (LADSPA_Data) ss.rate;
- upper *= (LADSPA_Data) ss.rate;
- }
-
- switch (hint & LADSPA_HINT_DEFAULT_MASK) {
-
- case LADSPA_HINT_DEFAULT_MINIMUM:
- u->control[h] = lower;
- break;
-
- case LADSPA_HINT_DEFAULT_MAXIMUM:
- u->control[h] = upper;
- break;
-
- case LADSPA_HINT_DEFAULT_LOW:
- if (LADSPA_IS_HINT_LOGARITHMIC(hint))
- u->control[h] = (LADSPA_Data) exp(log(lower) * 0.75 + log(upper) * 0.25);
- else
- u->control[h] = (LADSPA_Data) (lower * 0.75 + upper * 0.25);
- break;
-
- case LADSPA_HINT_DEFAULT_MIDDLE:
- if (LADSPA_IS_HINT_LOGARITHMIC(hint))
- u->control[h] = (LADSPA_Data) exp(log(lower) * 0.5 + log(upper) * 0.5);
- else
- u->control[h] = (LADSPA_Data) (lower * 0.5 + upper * 0.5);
- break;
-
- case LADSPA_HINT_DEFAULT_HIGH:
- if (LADSPA_IS_HINT_LOGARITHMIC(hint))
- u->control[h] = (LADSPA_Data) exp(log(lower) * 0.25 + log(upper) * 0.75);
- else
- u->control[h] = (LADSPA_Data) (lower * 0.25 + upper * 0.75);
- break;
-
- case LADSPA_HINT_DEFAULT_0:
- u->control[h] = 0;
- break;
-
- case LADSPA_HINT_DEFAULT_1:
- u->control[h] = 1;
- break;
-
- case LADSPA_HINT_DEFAULT_100:
- u->control[h] = 100;
- break;
-
- case LADSPA_HINT_DEFAULT_440:
- u->control[h] = 440;
- break;
-
- default:
- pa_assert_not_reached();
- }
- }
-
- if (LADSPA_IS_HINT_INTEGER(hint))
- u->control[h] = roundf(u->control[h]);
-
- pa_log_debug("Binding %f to port %s", u->control[h], d->PortNames[p]);
-
- for (c = 0; c < (u->channels / u->max_ladspaport_count); c++)
- d->connect_port(u->handle[c], p, &u->control[h]);
-
- h++;
- }
-
- pa_assert(h == n_control);
+ connect_control_ports(u);
+ pa_xfree(control_values);
+ pa_xfree(use_default);
}
if (d->activate)
@@ -940,8 +1326,11 @@ int pa__init(pa_module*m) {
pa_sink_put(u->sink);
pa_sink_input_put(u->sink_input);
+#if HAVE_DBUS
+ dbus_init(u);
+#endif
+
pa_modargs_free(ma);
- pa_xfree(use_default);
return 0;
@@ -949,8 +1338,6 @@ fail:
if (ma)
pa_modargs_free(ma);
- pa_xfree(use_default);
-
pa__done(m);
return -1;
@@ -977,6 +1364,10 @@ void pa__done(pa_module*m) {
/* See comments in sink_input_kill_cb() above regarding
* destruction order! */
+#if HAVE_DBUS
+ dbus_done(u);
+#endif
+
if (u->sink_input)
pa_sink_input_unlink(u->sink_input);
@@ -1020,5 +1411,6 @@ void pa__done(pa_module*m) {
pa_memblockq_free(u->memblockq);
pa_xfree(u->control);
+ pa_xfree(u->use_default);
pa_xfree(u);
}
--
1.7.10.2
More information about the pulseaudio-discuss
mailing list