src/ladspa.c

   1 /* LADSPA effect support for sox
   2  * (c) Reuben Thomas <rrt@sc3d.org> 2007
   3  *
   4  * This library is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or (at
   7  * your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with this library; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include "sox_i.h"
  20
  21 #ifdef HAVE_LADSPA_H
  22
  23 #include <assert.h>
  24 #include <limits.h>
  25 #include <string.h>
  26 #include <math.h>
  27 #include "ladspa.h"
  28
  29 /*
  30  * Assuming LADSPA_Data == float.  This is the case in 2012 and has been
  31  * the case for many years now.
  32  */
  33 #define SOX_SAMPLE_TO_LADSPA_DATA(d,clips) \
  34         SOX_SAMPLE_TO_FLOAT_32BIT((d),(clips))
  35 #define LADSPA_DATA_TO_SOX_SAMPLE(d,clips) \
  36         SOX_FLOAT_32BIT_TO_SAMPLE((d),(clips))
  37
  38 static sox_effect_handler_t sox_ladspa_effect;
  39
  40 /* Private data for resampling */
  41 typedef struct {
  42   char *name;                   /* plugin name */
  43   lt_dlhandle lth;              /* dynamic object handle */
  44   sox_bool clone;
  45   const LADSPA_Descriptor *desc; /* plugin descriptor */
  46   LADSPA_Handle *handles;        /* instantiated plugin handles */
  47   size_t handle_count;
  48   LADSPA_Data *control;         /* control ports */
  49   unsigned long *inputs;
  50   size_t input_count;
  51   unsigned long *outputs;
  52   size_t output_count;
  53   sox_bool latency_compensation;
  54   LADSPA_Data *latency_control_port;
  55   unsigned long in_latency;
  56   unsigned long out_latency;
  57 } priv_t;
  58
  59 static LADSPA_Data ladspa_default(const LADSPA_PortRangeHint *p)
  60 {
  61   LADSPA_Data d;
  62
  63   if (LADSPA_IS_HINT_DEFAULT_0(p->HintDescriptor))
  64     d = 0.0;
  65   else if (LADSPA_IS_HINT_DEFAULT_1(p->HintDescriptor))
  66     d = 1.0;
  67   else if (LADSPA_IS_HINT_DEFAULT_100(p->HintDescriptor))
  68     d = 100.0;
  69   else if (LADSPA_IS_HINT_DEFAULT_440(p->HintDescriptor))
  70     d = 440.0;
  71   else if (LADSPA_IS_HINT_DEFAULT_MINIMUM(p->HintDescriptor))
  72     d = p->LowerBound;
  73   else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(p->HintDescriptor))
  74     d = p->UpperBound;
  75   else if (LADSPA_IS_HINT_DEFAULT_LOW(p->HintDescriptor)) {
  76     if (LADSPA_IS_HINT_LOGARITHMIC(p->HintDescriptor))
  77       d = exp(log(p->LowerBound) * 0.75 + log(p->UpperBound) * 0.25);
  78     else
  79       d = p->LowerBound * 0.75 + p->UpperBound * 0.25;
  80   } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(p->HintDescriptor)) {
  81     if (LADSPA_IS_HINT_LOGARITHMIC(p->HintDescriptor))
  82       d = exp(log(p->LowerBound) * 0.5 + log(p->UpperBound) * 0.5);
  83     else
  84       d = p->LowerBound * 0.5 + p->UpperBound * 0.5;
  85   } else if (LADSPA_IS_HINT_DEFAULT_HIGH(p->HintDescriptor)) {
  86     if (LADSPA_IS_HINT_LOGARITHMIC(p->HintDescriptor))
  87       d = exp(log(p->LowerBound) * 0.25 + log(p->UpperBound) * 0.75);
  88     else
  89       d = p->LowerBound * 0.25 + p->UpperBound * 0.75;
  90   } else { /* shouldn't happen */
  91     /* FIXME: Deal with this at a higher level */
  92     lsx_fail("non-existent default value; using 0.1");
  93     d = 0.1; /* Should at least avoid divide by 0 */
  94   }
  95
  96   return d;
  97 }
  98
  99 /*
 100  * Process options
 101  */
 102 static int sox_ladspa_getopts(sox_effect_t *effp, int argc, char **argv)
 103 {
 104   priv_t * l_st = (priv_t *)effp->priv;
 105   char *path;
 106   int c;
 107   union {LADSPA_Descriptor_Function fn; lt_ptr ptr;} ltptr;
 108   unsigned long index = 0, i;
 109   double arg;
 110   lsx_getopt_t optstate;
 111   lsx_getopt_init(argc, argv, "+rl", NULL, lsx_getopt_flag_none, 1, &optstate);
 112
 113   while ((c = lsx_getopt(&optstate)) != -1) switch (c) {
 114     case 'r': l_st->clone = sox_true; break;
 115     case 'l': l_st->latency_compensation = sox_true; break;
 116     default:
 117       lsx_fail("unknown option `-%c'", optstate.opt);
 118       return lsx_usage(effp);
 119   }
 120   argc -= optstate.ind, argv += optstate.ind;
 121
 122   /* Get module name */
 123   if (argc >= 1) {
 124     l_st->name = argv[0];
 125     argc--; argv++;
 126   }
 127
 128   /* Load module */
 129   path = getenv("LADSPA_PATH");
 130   if (path == NULL)
 131     path = LADSPA_PATH;
 132
 133   if(lt_dlinit() || lt_dlsetsearchpath(path)
 134       || (l_st->lth = lt_dlopenext(l_st->name)) == NULL) {
 135     lsx_fail("could not open LADSPA plugin %s", l_st->name);
 136     return SOX_EOF;
 137   }
 138
 139   /* Get descriptor function */
 140   if ((ltptr.ptr = lt_dlsym(l_st->lth, "ladspa_descriptor")) == NULL) {
 141     lsx_fail("could not find ladspa_descriptor");
 142     return SOX_EOF;
 143   }
 144
 145   /* If no plugins in this module, complain */
 146   if (ltptr.fn(0UL) == NULL) {
 147     lsx_fail("no plugins found");
 148     return SOX_EOF;
 149   }
 150
 151   /* Get first plugin descriptor */
 152   l_st->desc = ltptr.fn(0UL);
 153   assert(l_st->desc);           /* We already know this will work */
 154
 155   /* If more than one plugin, or first argument is not a number, try
 156      to use first argument as plugin label. */
 157   if (argc > 0 && (ltptr.fn(1UL) != NULL || !sscanf(argv[0], "%lf", &arg))) {
 158     while (l_st->desc && strcmp(l_st->desc->Label, argv[0]) != 0)
 159       l_st->desc = ltptr.fn(++index);
 160     if (l_st->desc == NULL) {
 161       lsx_fail("no plugin called `%s' found", argv[0]);
 162       return SOX_EOF;
 163     }
 164     argc--; argv++;
 165   }
 166
 167   /* Scan the ports for inputs and outputs */
 168   l_st->control = lsx_calloc(l_st->desc->PortCount, sizeof(LADSPA_Data));
 169   l_st->inputs = lsx_malloc(l_st->desc->PortCount * sizeof(unsigned long));
 170   l_st->outputs = lsx_malloc(l_st->desc->PortCount * sizeof(unsigned long));
 171
 172   for (i = 0; i < l_st->desc->PortCount; i++) {
 173     const LADSPA_PortDescriptor port = l_st->desc->PortDescriptors[i];
 174
 175     /* Check port is well specified. All control ports should be
 176        inputs, but don't bother checking, as we never rely on this. */
 177     if (LADSPA_IS_PORT_INPUT(port) && LADSPA_IS_PORT_OUTPUT(port)) {
 178       lsx_fail("port %lu is both input and output", i);
 179       return SOX_EOF;
 180     } else if (LADSPA_IS_PORT_CONTROL(port) && LADSPA_IS_PORT_AUDIO(port)) {
 181       lsx_fail("port %lu is both audio and control", i);
 182       return SOX_EOF;
 183     }
 184
 185     if (LADSPA_IS_PORT_AUDIO(port)) {
 186       if (LADSPA_IS_PORT_INPUT(port)) {
 187         l_st->inputs[l_st->input_count++] = i;
 188       } else if (LADSPA_IS_PORT_OUTPUT(port)) {
 189         l_st->outputs[l_st->output_count++] = i;
 190       }
 191     } else {                    /* Control port */
 192       if (l_st->latency_compensation &&
 193           LADSPA_IS_PORT_CONTROL(port) &&
 194           LADSPA_IS_PORT_OUTPUT(port) &&
 195           strcmp(l_st->desc->PortNames[i], "latency") == 0) {
 196         /* automatic latency compensation, Ardour does this, too */
 197         l_st->latency_control_port = &l_st->control[i];
 198         assert(*l_st->latency_control_port == 0);
 199         lsx_debug("latency control port is %lu", i);
 200       } else if (argc == 0) {
 201         if (!LADSPA_IS_HINT_HAS_DEFAULT(l_st->desc->PortRangeHints[i].HintDescriptor)) {
 202           lsx_fail("not enough arguments for control ports");
 203           return SOX_EOF;
 204         }
 205         l_st->control[i] = ladspa_default(&(l_st->desc->PortRangeHints[i]));
 206         lsx_debug("default argument for port %lu is %f", i, l_st->control[i]);
 207       } else {
 208         if (!sscanf(argv[0], "%lf", &arg))
 209           return lsx_usage(effp);
 210         l_st->control[i] = (LADSPA_Data)arg;
 211         lsx_debug("argument for port %lu is %f", i, l_st->control[i]);
 212         argc--; argv++;
 213       }
 214     }
 215   }
 216
 217   /* Stop if we have any unused arguments */
 218   return argc? lsx_usage(effp) : SOX_SUCCESS;
 219 }
 220
 221 /*
 222  * Prepare processing.
 223  */
 224 static int sox_ladspa_start(sox_effect_t * effp)
 225 {
 226   priv_t * l_st = (priv_t *)effp->priv;
 227   unsigned long i;
 228   size_t h;
 229   unsigned long rate = (unsigned long)effp->in_signal.rate;
 230
 231   /* Instantiate the plugin */
 232   lsx_debug("rate for plugin is %g", effp->in_signal.rate);
 233
 234   if (l_st->input_count == 1 && l_st->output_count == 1 &&
 235       effp->in_signal.channels == effp->out_signal.channels) {
 236     /* for mono plugins, they are common */
 237
 238     if (!l_st->clone && effp->in_signal.channels > 1) {
 239       lsx_fail("expected 1 input channel(s), found %u; consider using -r",
 240                effp->in_signal.channels);
 241       return SOX_EOF;
 242     }
 243
 244     /*
 245      * create one handle per channel for mono plugins. ecasound does this, too.
 246      * mono LADSPA plugins are common and SoX supported mono LADSPA plugins
 247      * exclusively for a while.
 248      */
 249     l_st->handles = lsx_malloc(effp->in_signal.channels *
 250                                sizeof(LADSPA_Handle *));
 251
 252     while (l_st->handle_count < effp->in_signal.channels)
 253       l_st->handles[l_st->handle_count++] = l_st->desc->instantiate(l_st->desc, rate);
 254
 255   } else {
 256     /*
 257      * assume the plugin is multi-channel capable with one instance,
 258      * Some LADSPA plugins are stereo (e.g. bs2b-ladspa)
 259      */
 260
 261     if (l_st->input_count < effp->in_signal.channels) {
 262       lsx_fail("fewer plugin input ports than input channels (%u < %u)",
 263                (unsigned)l_st->input_count, effp->in_signal.channels);
 264       return SOX_EOF;
 265     }
 266
 267     /* warn if LADSPA audio ports are unused.  ecasound does this, too */
 268     if (l_st->input_count > effp->in_signal.channels)
 269       lsx_warn("more plugin input ports than input channels (%u > %u)",
 270                (unsigned)l_st->input_count, effp->in_signal.channels);
 271
 272     /*
 273      * some LADSPA plugins increase/decrease the channel count
 274      * (e.g. "mixer" in cmt or vocoder):
 275      */
 276     if (l_st->output_count != effp->out_signal.channels) {
 277       lsx_debug("changing output channels to match plugin output ports (%u => %u)",
 278                effp->out_signal.channels, (unsigned)l_st->output_count);
 279       effp->out_signal.channels = l_st->output_count;
 280     }
 281
 282     l_st->handle_count = 1;
 283     l_st->handles = lsx_malloc(sizeof(LADSPA_Handle *));
 284     l_st->handles[0] = l_st->desc->instantiate(l_st->desc, rate);
 285   }
 286
 287   /* abandon everything completely on any failed handle instantiation */
 288   for (h = 0; h < l_st->handle_count; h++) {
 289     if (l_st->handles[h] == NULL) {
 290       /* cleanup the handles that did instantiate successfully */
 291       for (h = 0; l_st->desc->cleanup && h < l_st->handle_count; h++) {
 292         if (l_st->handles[h])
 293           l_st->desc->cleanup(l_st->handles[h]);
 294       }
 295
 296       free(l_st->handles);
 297       l_st->handle_count = 0;
 298       lsx_fail("could not instantiate plugin");
 299       return SOX_EOF;
 300     }
 301   }
 302
 303   for (i = 0; i < l_st->desc->PortCount; i++) {
 304     const LADSPA_PortDescriptor port = l_st->desc->PortDescriptors[i];
 305
 306     if (LADSPA_IS_PORT_CONTROL(port)) {
 307       for (h = 0; h < l_st->handle_count; h++)
 308         l_st->desc->connect_port(l_st->handles[h], i, &(l_st->control[i]));
 309     }
 310   }
 311
 312   /* If needed, activate the plugin instances */
 313   if (l_st->desc->activate) {
 314     for (h = 0; h < l_st->handle_count; h++)
 315       l_st->desc->activate(l_st->handles[h]);
 316   }
 317
 318   return SOX_SUCCESS;
 319 }
 320
 321 /*
 322  * Process one bufferful of data.
 323  */
 324 static int sox_ladspa_flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
 325                            size_t *isamp, size_t *osamp)
 326 {
 327   priv_t * l_st = (priv_t *)effp->priv;
 328   size_t i, len = min(*isamp, *osamp);
 329   size_t j;
 330   size_t h;
 331   const size_t total_input_count = l_st->input_count * l_st->handle_count;
 332   const size_t total_output_count = l_st->output_count * l_st->handle_count;
 333   const size_t input_len = len / total_input_count;
 334   size_t output_len = len / total_output_count;
 335
 336   if (total_output_count < total_input_count)
 337     output_len = input_len;
 338
 339   *isamp = len;
 340   *osamp = 0;
 341
 342   if (len) {
 343     LADSPA_Data *buf = lsx_calloc(len, sizeof(LADSPA_Data));
 344     LADSPA_Data *outbuf = lsx_calloc(len, sizeof(LADSPA_Data));
 345     LADSPA_Handle handle;
 346     unsigned long port, l;
 347     SOX_SAMPLE_LOCALS;
 348
 349     /*
 350      * prepare buffer for LADSPA input
 351      * deinterleave sox samples and write non-interleaved data to
 352      * input_port-specific buffer locations
 353      */
 354     for (i = 0; i < input_len; i++) {
 355       for (j = 0; j < total_input_count; j++) {
 356         const sox_sample_t s = *ibuf++;
 357         buf[j * input_len + i] = SOX_SAMPLE_TO_LADSPA_DATA(s, effp->clips);
 358       }
 359     }
 360
 361     /* Connect the LADSPA input port(s) to the prepared buffers */
 362     for (j = 0; j < total_input_count; j++) {
 363       handle = l_st->handles[j / l_st->input_count];
 364       port = l_st->inputs[j / l_st->handle_count];
 365       l_st->desc->connect_port(handle, port, buf + j * input_len);
 366     }
 367
 368     /* Connect the LADSPA output port(s) if used */
 369     for (j = 0; j < total_output_count; j++) {
 370       handle = l_st->handles[j / l_st->output_count];
 371       port = l_st->outputs[j / l_st->handle_count];
 372       l_st->desc->connect_port(handle, port, outbuf + j * output_len);
 373     }
 374
 375     /* Run the plugin for each handle */
 376     for (h = 0; h < l_st->handle_count; h++)
 377       l_st->desc->run(l_st->handles[h], input_len);
 378
 379     /* check the latency control port if we have one */
 380     if (l_st->latency_control_port) {
 381       lsx_debug("latency detected is %g", *l_st->latency_control_port);
 382       l_st->in_latency = (unsigned long)floor(*l_st->latency_control_port);
 383
 384       /* we will need this later in sox_ladspa_drain */
 385       l_st->out_latency = l_st->in_latency;
 386
 387       /* latency for plugins is constant, only compensate once */
 388       l_st->latency_control_port = NULL;
 389     }
 390
 391     /* Grab output if effect produces it, re-interleaving it */
 392     l = min(output_len, l_st->in_latency);
 393     for (i = l; i < output_len; i++) {
 394       for (j = 0; j < total_output_count; j++) {
 395         LADSPA_Data d = outbuf[j * output_len + i];
 396         *obuf++ = LADSPA_DATA_TO_SOX_SAMPLE(d, effp->clips);
 397         (*osamp)++;
 398       }
 399     }
 400     l_st->in_latency -= l;
 401
 402     free(outbuf);
 403     free(buf);
 404   }
 405
 406   return SOX_SUCCESS;
 407 }
 408
 409 /*
 410  * Nothing to do if the plugin has no latency or latency compensation is
 411  * disabled.
 412  */
 413 static int sox_ladspa_drain(sox_effect_t * effp, sox_sample_t *obuf, size_t *osamp)
 414 {
 415   priv_t * l_st = (priv_t *)effp->priv;
 416   sox_sample_t *ibuf, *dbuf;
 417   size_t isamp, dsamp;
 418   int r;
 419
 420   if (l_st->out_latency == 0) {
 421     *osamp = 0;
 422     return SOX_SUCCESS;
 423   }
 424
 425   /* feed some silence at the end to push the rest of the data out */
 426   isamp = l_st->out_latency * effp->in_signal.channels;
 427   dsamp = l_st->out_latency * effp->out_signal.channels;
 428   ibuf = lsx_calloc(isamp, sizeof(sox_sample_t));
 429   dbuf = lsx_calloc(dsamp, sizeof(sox_sample_t));
 430
 431   r = sox_ladspa_flow(effp, ibuf, dbuf, &isamp, &dsamp);
 432   *osamp = min(dsamp, *osamp);
 433   memcpy(obuf, dbuf, *osamp * sizeof(sox_sample_t));
 434
 435   free(ibuf);
 436   free(dbuf);
 437
 438   return r == SOX_SUCCESS ? SOX_EOF : 0;
 439 }
 440
 441 /*
 442  * Do anything required when you stop reading samples.
 443  * Don't close input file!
 444  */
 445 static int sox_ladspa_stop(sox_effect_t * effp)
 446 {
 447   priv_t * l_st = (priv_t *)effp->priv;
 448   size_t h;
 449
 450   for (h = 0; h < l_st->handle_count; h++) {
 451     /* If needed, deactivate and cleanup the plugin */
 452     if (l_st->desc->deactivate)
 453       l_st->desc->deactivate(l_st->handles[h]);
 454     if (l_st->desc->cleanup)
 455       l_st->desc->cleanup(l_st->handles[h]);
 456   }
 457   free(l_st->handles);
 458   l_st->handle_count = 0;
 459
 460   return SOX_SUCCESS;
 461 }
 462
 463 static int sox_ladspa_kill(sox_effect_t * effp)
 464 {
 465   priv_t * l_st = (priv_t *)effp->priv;
 466
 467   free(l_st->control);
 468   free(l_st->inputs);
 469   free(l_st->outputs);
 470
 471   return SOX_SUCCESS;
 472 }
 473
 474 static sox_effect_handler_t sox_ladspa_effect = {
 475   "ladspa",
 476   "MODULE [PLUGIN] [ARGUMENT...]",
 477   SOX_EFF_MCHAN | SOX_EFF_CHAN | SOX_EFF_GAIN,
 478   sox_ladspa_getopts,
 479   sox_ladspa_start,
 480   sox_ladspa_flow,
 481   sox_ladspa_drain,
 482   sox_ladspa_stop,
 483   sox_ladspa_kill,
 484   sizeof(priv_t)
 485 };
 486
 487 const sox_effect_handler_t *lsx_ladspa_effect_fn(void)
 488 {
 489   return &sox_ladspa_effect;
 490 }
 491
 492 #endif /* HAVE_LADSPA */