ref: 579fae4ab7d37423aee4d9cdf7a29f9d96c2b764
dir: /src/ladspa.c/
/* LADSPA effect support for sox
* (c) Reuben Thomas <rrt@sc3d.org> 2007
*
* This library 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.1 of the License, or (at
* your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "sox_i.h"
#ifdef HAVE_LADSPA_H
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <math.h>
#include "ladspa.h"
/*
* Assuming LADSPA_Data == float. This is the case in 2012 and has been
* the case for many years now.
*/
#define SOX_SAMPLE_TO_LADSPA_DATA(d,clips) \
SOX_SAMPLE_TO_FLOAT_32BIT((d),(clips))
#define LADSPA_DATA_TO_SOX_SAMPLE(d,clips) \
SOX_FLOAT_32BIT_TO_SAMPLE((d),(clips))
static sox_effect_handler_t sox_ladspa_effect;
/* Private data for resampling */
typedef struct {
char *name; /* plugin name */
lt_dlhandle lth; /* dynamic object handle */
sox_bool clone;
const LADSPA_Descriptor *desc; /* plugin descriptor */
LADSPA_Handle *handles; /* instantiated plugin handles */
size_t handle_count;
LADSPA_Data *control; /* control ports */
unsigned long *inputs;
size_t input_count;
unsigned long *outputs;
size_t output_count;
sox_bool latency_compensation;
LADSPA_Data *latency_control_port;
unsigned long in_latency;
unsigned long out_latency;
} priv_t;
static LADSPA_Data ladspa_default(const LADSPA_PortRangeHint *p)
{
LADSPA_Data d;
if (LADSPA_IS_HINT_DEFAULT_0(p->HintDescriptor))
d = 0.0;
else if (LADSPA_IS_HINT_DEFAULT_1(p->HintDescriptor))
d = 1.0;
else if (LADSPA_IS_HINT_DEFAULT_100(p->HintDescriptor))
d = 100.0;
else if (LADSPA_IS_HINT_DEFAULT_440(p->HintDescriptor))
d = 440.0;
else if (LADSPA_IS_HINT_DEFAULT_MINIMUM(p->HintDescriptor))
d = p->LowerBound;
else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(p->HintDescriptor))
d = p->UpperBound;
else if (LADSPA_IS_HINT_DEFAULT_LOW(p->HintDescriptor)) {
if (LADSPA_IS_HINT_LOGARITHMIC(p->HintDescriptor))
d = exp(log(p->LowerBound) * 0.75 + log(p->UpperBound) * 0.25);
else
d = p->LowerBound * 0.75 + p->UpperBound * 0.25;
} else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(p->HintDescriptor)) {
if (LADSPA_IS_HINT_LOGARITHMIC(p->HintDescriptor))
d = exp(log(p->LowerBound) * 0.5 + log(p->UpperBound) * 0.5);
else
d = p->LowerBound * 0.5 + p->UpperBound * 0.5;
} else if (LADSPA_IS_HINT_DEFAULT_HIGH(p->HintDescriptor)) {
if (LADSPA_IS_HINT_LOGARITHMIC(p->HintDescriptor))
d = exp(log(p->LowerBound) * 0.25 + log(p->UpperBound) * 0.75);
else
d = p->LowerBound * 0.25 + p->UpperBound * 0.75;
} else { /* shouldn't happen */
/* FIXME: Deal with this at a higher level */
lsx_fail("non-existent default value; using 0.1");
d = 0.1; /* Should at least avoid divide by 0 */
}
return d;
}
/*
* Process options
*/
static int sox_ladspa_getopts(sox_effect_t *effp, int argc, char **argv)
{
priv_t * l_st = (priv_t *)effp->priv;
char *path;
int c;
union {LADSPA_Descriptor_Function fn; lt_ptr ptr;} ltptr;
unsigned long index = 0, i;
double arg;
lsx_getopt_t optstate;
lsx_getopt_init(argc, argv, "+rl", NULL, lsx_getopt_flag_none, 1, &optstate);
while ((c = lsx_getopt(&optstate)) != -1) switch (c) {
case 'r': l_st->clone = sox_true; break;
case 'l': l_st->latency_compensation = sox_true; break;
default:
lsx_fail("unknown option `-%c'", optstate.opt);
return lsx_usage(effp);
}
argc -= optstate.ind, argv += optstate.ind;
/* Get module name */
if (argc >= 1) {
l_st->name = argv[0];
argc--; argv++;
}
/* Load module */
path = getenv("LADSPA_PATH");
if (path == NULL)
path = LADSPA_PATH;
if(lt_dlinit() || lt_dlsetsearchpath(path)
|| (l_st->lth = lt_dlopenext(l_st->name)) == NULL) {
lsx_fail("could not open LADSPA plugin %s", l_st->name);
return SOX_EOF;
}
/* Get descriptor function */
if ((ltptr.ptr = lt_dlsym(l_st->lth, "ladspa_descriptor")) == NULL) {
lsx_fail("could not find ladspa_descriptor");
return SOX_EOF;
}
/* If no plugins in this module, complain */
if (ltptr.fn(0UL) == NULL) {
lsx_fail("no plugins found");
return SOX_EOF;
}
/* Get first plugin descriptor */
l_st->desc = ltptr.fn(0UL);
assert(l_st->desc); /* We already know this will work */
/* If more than one plugin, or first argument is not a number, try
to use first argument as plugin label. */
if (argc > 0 && (ltptr.fn(1UL) != NULL || !sscanf(argv[0], "%lf", &arg))) {
while (l_st->desc && strcmp(l_st->desc->Label, argv[0]) != 0)
l_st->desc = ltptr.fn(++index);
if (l_st->desc == NULL) {
lsx_fail("no plugin called `%s' found", argv[0]);
return SOX_EOF;
}
argc--; argv++;
}
/* Scan the ports for inputs and outputs */
l_st->control = lsx_calloc(l_st->desc->PortCount, sizeof(LADSPA_Data));
l_st->inputs = lsx_malloc(l_st->desc->PortCount * sizeof(unsigned long));
l_st->outputs = lsx_malloc(l_st->desc->PortCount * sizeof(unsigned long));
for (i = 0; i < l_st->desc->PortCount; i++) {
const LADSPA_PortDescriptor port = l_st->desc->PortDescriptors[i];
/* Check port is well specified. All control ports should be
inputs, but don't bother checking, as we never rely on this. */
if (LADSPA_IS_PORT_INPUT(port) && LADSPA_IS_PORT_OUTPUT(port)) {
lsx_fail("port %lu is both input and output", i);
return SOX_EOF;
} else if (LADSPA_IS_PORT_CONTROL(port) && LADSPA_IS_PORT_AUDIO(port)) {
lsx_fail("port %lu is both audio and control", i);
return SOX_EOF;
}
if (LADSPA_IS_PORT_AUDIO(port)) {
if (LADSPA_IS_PORT_INPUT(port)) {
l_st->inputs[l_st->input_count++] = i;
} else if (LADSPA_IS_PORT_OUTPUT(port)) {
l_st->outputs[l_st->output_count++] = i;
}
} else { /* Control port */
if (l_st->latency_compensation &&
LADSPA_IS_PORT_CONTROL(port) &&
LADSPA_IS_PORT_OUTPUT(port) &&
strcmp(l_st->desc->PortNames[i], "latency") == 0) {
/* automatic latency compensation, Ardour does this, too */
l_st->latency_control_port = &l_st->control[i];
assert(*l_st->latency_control_port == 0);
lsx_debug("latency control port is %lu", i);
} else if (argc == 0) {
if (!LADSPA_IS_HINT_HAS_DEFAULT(l_st->desc->PortRangeHints[i].HintDescriptor)) {
lsx_fail("not enough arguments for control ports");
return SOX_EOF;
}
l_st->control[i] = ladspa_default(&(l_st->desc->PortRangeHints[i]));
lsx_debug("default argument for port %lu is %f", i, l_st->control[i]);
} else {
if (!sscanf(argv[0], "%lf", &arg))
return lsx_usage(effp);
l_st->control[i] = (LADSPA_Data)arg;
lsx_debug("argument for port %lu is %f", i, l_st->control[i]);
argc--; argv++;
}
}
}
/* Stop if we have any unused arguments */
return argc? lsx_usage(effp) : SOX_SUCCESS;
}
/*
* Prepare processing.
*/
static int sox_ladspa_start(sox_effect_t * effp)
{
priv_t * l_st = (priv_t *)effp->priv;
unsigned long i;
size_t h;
unsigned long rate = (unsigned long)effp->in_signal.rate;
/* Instantiate the plugin */
lsx_debug("rate for plugin is %g", effp->in_signal.rate);
if (l_st->input_count == 1 && l_st->output_count == 1 &&
effp->in_signal.channels == effp->out_signal.channels) {
/* for mono plugins, they are common */
if (!l_st->clone && effp->in_signal.channels > 1) {
lsx_fail("expected 1 input channel(s), found %u; consider using -r",
effp->in_signal.channels);
return SOX_EOF;
}
/*
* create one handle per channel for mono plugins. ecasound does this, too.
* mono LADSPA plugins are common and SoX supported mono LADSPA plugins
* exclusively for a while.
*/
l_st->handles = lsx_malloc(effp->in_signal.channels *
sizeof(LADSPA_Handle *));
while (l_st->handle_count < effp->in_signal.channels)
l_st->handles[l_st->handle_count++] = l_st->desc->instantiate(l_st->desc, rate);
} else {
/*
* assume the plugin is multi-channel capable with one instance,
* Some LADSPA plugins are stereo (e.g. bs2b-ladspa)
*/
if (l_st->input_count < effp->in_signal.channels) {
lsx_fail("fewer plugin input ports than input channels (%u < %u)",
(unsigned)l_st->input_count, effp->in_signal.channels);
return SOX_EOF;
}
/* warn if LADSPA audio ports are unused. ecasound does this, too */
if (l_st->input_count > effp->in_signal.channels)
lsx_warn("more plugin input ports than input channels (%u > %u)",
(unsigned)l_st->input_count, effp->in_signal.channels);
/*
* some LADSPA plugins increase/decrease the channel count
* (e.g. "mixer" in cmt or vocoder):
*/
if (l_st->output_count != effp->out_signal.channels) {
lsx_debug("changing output channels to match plugin output ports (%u => %u)",
effp->out_signal.channels, (unsigned)l_st->output_count);
effp->out_signal.channels = l_st->output_count;
}
l_st->handle_count = 1;
l_st->handles = lsx_malloc(sizeof(LADSPA_Handle *));
l_st->handles[0] = l_st->desc->instantiate(l_st->desc, rate);
}
/* abandon everything completely on any failed handle instantiation */
for (h = 0; h < l_st->handle_count; h++) {
if (l_st->handles[h] == NULL) {
/* cleanup the handles that did instantiate successfully */
for (h = 0; l_st->desc->cleanup && h < l_st->handle_count; h++) {
if (l_st->handles[h])
l_st->desc->cleanup(l_st->handles[h]);
}
free(l_st->handles);
l_st->handle_count = 0;
lsx_fail("could not instantiate plugin");
return SOX_EOF;
}
}
for (i = 0; i < l_st->desc->PortCount; i++) {
const LADSPA_PortDescriptor port = l_st->desc->PortDescriptors[i];
if (LADSPA_IS_PORT_CONTROL(port)) {
for (h = 0; h < l_st->handle_count; h++)
l_st->desc->connect_port(l_st->handles[h], i, &(l_st->control[i]));
}
}
/* If needed, activate the plugin instances */
if (l_st->desc->activate) {
for (h = 0; h < l_st->handle_count; h++)
l_st->desc->activate(l_st->handles[h]);
}
return SOX_SUCCESS;
}
/*
* Process one bufferful of data.
*/
static int sox_ladspa_flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
size_t *isamp, size_t *osamp)
{
priv_t * l_st = (priv_t *)effp->priv;
size_t i, len = min(*isamp, *osamp);
size_t j;
size_t h;
const size_t total_input_count = l_st->input_count * l_st->handle_count;
const size_t total_output_count = l_st->output_count * l_st->handle_count;
const size_t input_len = len / total_input_count;
size_t output_len = len / total_output_count;
if (total_output_count < total_input_count)
output_len = input_len;
*isamp = len;
*osamp = 0;
if (len) {
LADSPA_Data *buf = lsx_calloc(len, sizeof(LADSPA_Data));
LADSPA_Data *outbuf = lsx_calloc(len, sizeof(LADSPA_Data));
LADSPA_Handle handle;
unsigned long port, l;
SOX_SAMPLE_LOCALS;
/*
* prepare buffer for LADSPA input
* deinterleave sox samples and write non-interleaved data to
* input_port-specific buffer locations
*/
for (i = 0; i < input_len; i++) {
for (j = 0; j < total_input_count; j++) {
const sox_sample_t s = *ibuf++;
buf[j * input_len + i] = SOX_SAMPLE_TO_LADSPA_DATA(s, effp->clips);
}
}
/* Connect the LADSPA input port(s) to the prepared buffers */
for (j = 0; j < total_input_count; j++) {
handle = l_st->handles[j / l_st->input_count];
port = l_st->inputs[j / l_st->handle_count];
l_st->desc->connect_port(handle, port, buf + j * input_len);
}
/* Connect the LADSPA output port(s) if used */
for (j = 0; j < total_output_count; j++) {
handle = l_st->handles[j / l_st->output_count];
port = l_st->outputs[j / l_st->handle_count];
l_st->desc->connect_port(handle, port, outbuf + j * output_len);
}
/* Run the plugin for each handle */
for (h = 0; h < l_st->handle_count; h++)
l_st->desc->run(l_st->handles[h], input_len);
/* check the latency control port if we have one */
if (l_st->latency_control_port) {
lsx_debug("latency detected is %g", *l_st->latency_control_port);
l_st->in_latency = (unsigned long)floor(*l_st->latency_control_port);
/* we will need this later in sox_ladspa_drain */
l_st->out_latency = l_st->in_latency;
/* latency for plugins is constant, only compensate once */
l_st->latency_control_port = NULL;
}
/* Grab output if effect produces it, re-interleaving it */
l = min(output_len, l_st->in_latency);
for (i = l; i < output_len; i++) {
for (j = 0; j < total_output_count; j++) {
LADSPA_Data d = outbuf[j * output_len + i];
*obuf++ = LADSPA_DATA_TO_SOX_SAMPLE(d, effp->clips);
(*osamp)++;
}
}
l_st->in_latency -= l;
free(outbuf);
free(buf);
}
return SOX_SUCCESS;
}
/*
* Nothing to do if the plugin has no latency or latency compensation is
* disabled.
*/
static int sox_ladspa_drain(sox_effect_t * effp, sox_sample_t *obuf, size_t *osamp)
{
priv_t * l_st = (priv_t *)effp->priv;
sox_sample_t *ibuf, *dbuf;
size_t isamp, dsamp;
int r;
if (l_st->out_latency == 0) {
*osamp = 0;
return SOX_SUCCESS;
}
/* feed some silence at the end to push the rest of the data out */
isamp = l_st->out_latency * effp->in_signal.channels;
dsamp = l_st->out_latency * effp->out_signal.channels;
ibuf = lsx_calloc(isamp, sizeof(sox_sample_t));
dbuf = lsx_calloc(dsamp, sizeof(sox_sample_t));
r = sox_ladspa_flow(effp, ibuf, dbuf, &isamp, &dsamp);
*osamp = min(dsamp, *osamp);
memcpy(obuf, dbuf, *osamp * sizeof(sox_sample_t));
free(ibuf);
free(dbuf);
return r == SOX_SUCCESS ? SOX_EOF : 0;
}
/*
* Do anything required when you stop reading samples.
* Don't close input file!
*/
static int sox_ladspa_stop(sox_effect_t * effp)
{
priv_t * l_st = (priv_t *)effp->priv;
size_t h;
for (h = 0; h < l_st->handle_count; h++) {
/* If needed, deactivate and cleanup the plugin */
if (l_st->desc->deactivate)
l_st->desc->deactivate(l_st->handles[h]);
if (l_st->desc->cleanup)
l_st->desc->cleanup(l_st->handles[h]);
}
free(l_st->handles);
l_st->handle_count = 0;
return SOX_SUCCESS;
}
static int sox_ladspa_kill(sox_effect_t * effp)
{
priv_t * l_st = (priv_t *)effp->priv;
free(l_st->control);
free(l_st->inputs);
free(l_st->outputs);
return SOX_SUCCESS;
}
static sox_effect_handler_t sox_ladspa_effect = {
"ladspa",
"MODULE [PLUGIN] [ARGUMENT...]",
SOX_EFF_MCHAN | SOX_EFF_CHAN | SOX_EFF_GAIN,
sox_ladspa_getopts,
sox_ladspa_start,
sox_ladspa_flow,
sox_ladspa_drain,
sox_ladspa_stop,
sox_ladspa_kill,
sizeof(priv_t)
};
const sox_effect_handler_t *lsx_ladspa_effect_fn(void)
{
return &sox_ladspa_effect;
}
#endif /* HAVE_LADSPA */