libs/ardour/ladspa_plugin.cc

   1 /*
   2     Copyright (C) 2000-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <vector>
  21 #include <string>
  22
  23 #include <cstdlib>
  24 #include <cstdio> // so libraptor doesn't complain
  25 #include <cmath>
  26 #include <dirent.h>
  27 #include <sys/stat.h>
  28 #include <cerrno>
  29
  30 #include <lrdf.h>
  31
  32 #include <pbd/compose.h>
  33 #include <pbd/error.h>
  34 #include <pbd/pathscanner.h>
  35 #include <pbd/xml++.h>
  36
  37 #include <midi++/manager.h>
  38
  39 #include <ardour/ardour.h>
  40 #include <ardour/session.h>
  41 #include <ardour/audioengine.h>
  42 #include <ardour/ladspa_plugin.h>
  43
  44 #include <pbd/stl_delete.h>
  45
  46 #include "i18n.h"
  47 #include <locale.h>
  48
  49 using namespace std;
  50 using namespace ARDOUR;
  51 using namespace PBD;
  52
  53 LadspaPlugin::LadspaPlugin (void *mod, AudioEngine& e, Session& session, uint32_t index, nframes_t rate)
  54         : Plugin (e, session)
  55 {
  56         init (mod, index, rate);
  57 }
  58
  59 LadspaPlugin::LadspaPlugin (const LadspaPlugin &other)
  60         : Plugin (other)
  61 {
  62         init (other._module, other._index, other._sample_rate);
  63
  64         for (uint32_t i = 0; i < parameter_count(); ++i) {
  65                 _control_data[i] = other._shadow_data[i];
  66                 _shadow_data[i] = other._shadow_data[i];
  67         }
  68 }
  69
  70 void
  71 LadspaPlugin::init (void *mod, uint32_t index, nframes_t rate)
  72 {
  73         LADSPA_Descriptor_Function dfunc;
  74         uint32_t i, port_cnt;
  75         const char *errstr;
  76
  77         _module = mod;
  78         _control_data = 0;
  79         _shadow_data = 0;
  80         _latency_control_port = 0;
  81         _was_activated = false;
  82
  83         dfunc = (LADSPA_Descriptor_Function) dlsym (_module, "ladspa_descriptor");
  84
  85         if ((errstr = dlerror()) != NULL) {
  86                 error << _("LADSPA: module has no descriptor function.") << endmsg;
  87                 throw failed_constructor();
  88         }
  89
  90         if ((_descriptor = dfunc (index)) == 0) {
  91                 error << _("LADSPA: plugin has gone away since discovery!") << endmsg;
  92                 throw failed_constructor();
  93         }
  94
  95         _index = index;
  96
  97         if (LADSPA_IS_INPLACE_BROKEN(_descriptor->Properties)) {
  98                 error << string_compose(_("LADSPA: \"%1\" cannot be used, since it cannot do inplace processing"), _descriptor->Name) << endmsg;
  99                 throw failed_constructor();
 100         }
 101
 102         _sample_rate = rate;
 103
 104         if (_descriptor->instantiate == 0) {
 105                 throw failed_constructor();
 106         }
 107
 108         if ((_handle = _descriptor->instantiate (_descriptor, rate)) == 0) {
 109                 throw failed_constructor();
 110         }
 111
 112         port_cnt = parameter_count();
 113
 114         _control_data = new LADSPA_Data[port_cnt];
 115         _shadow_data = new LADSPA_Data[port_cnt];
 116
 117         for (i = 0; i < port_cnt; ++i) {
 118                 if (LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
 119                         connect_port (i, &_control_data[i]);
 120
 121                         if (LADSPA_IS_PORT_OUTPUT(port_descriptor (i)) &&
 122                             strcmp (port_names()[i], X_("latency")) == 0) {
 123                                 _latency_control_port = &_control_data[i];
 124                                 *_latency_control_port = 0;
 125                         }
 126
 127                         if (!LADSPA_IS_PORT_INPUT(port_descriptor (i))) {
 128                                 continue;
 129                         }
 130
 131                         _shadow_data[i] = default_value (i);
 132                 }
 133         }
 134
 135         Plugin::setup_controls ();
 136
 137         latency_compute_run ();
 138 }
 139
 140 LadspaPlugin::~LadspaPlugin ()
 141 {
 142         deactivate ();
 143         cleanup ();
 144
 145         GoingAway (); /* EMIT SIGNAL */
 146
 147         /* XXX who should close a plugin? */
 148
 149         // dlclose (module);
 150
 151         if (_control_data) {
 152                 delete [] _control_data;
 153         }
 154
 155         if (_shadow_data) {
 156                 delete [] _shadow_data;
 157         }
 158 }
 159
 160 string
 161 LadspaPlugin::unique_id() const
 162 {
 163         char buf[32];
 164         snprintf (buf, sizeof (buf), "%lu", _descriptor->UniqueID);
 165         return string (buf);
 166 }
 167
 168
 169 float
 170 LadspaPlugin::default_value (uint32_t port)
 171 {
 172         const LADSPA_PortRangeHint *prh = port_range_hints();
 173         float ret = 0.0f;
 174         bool bounds_given = false;
 175         bool sr_scaling = false;
 176         bool earlier_hint = false;
 177
 178         /* defaults - case 1 */
 179
 180         if (LADSPA_IS_HINT_HAS_DEFAULT(prh[port].HintDescriptor)) {
 181                 if (LADSPA_IS_HINT_DEFAULT_MINIMUM(prh[port].HintDescriptor)) {
 182                         ret = prh[port].LowerBound;
 183                         bounds_given = true;
 184                         sr_scaling = true;
 185                         earlier_hint = true;
 186                 }
 187
 188                 /* FIXME: add support for logarithmic defaults */
 189
 190                 else if (LADSPA_IS_HINT_DEFAULT_LOW(prh[port].HintDescriptor)) {
 191                         ret = prh[port].LowerBound * 0.75f + prh[port].UpperBound * 0.25f;
 192                         bounds_given = true;
 193                         sr_scaling = true;
 194                         earlier_hint = true;
 195                 }
 196                 else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(prh[port].HintDescriptor)) {
 197                         ret = prh[port].LowerBound * 0.50f + prh[port].UpperBound * 0.50f;
 198                         bounds_given = true;
 199                         sr_scaling = true;
 200                         earlier_hint = true;
 201                 }
 202                 else if (LADSPA_IS_HINT_DEFAULT_HIGH(prh[port].HintDescriptor)) {
 203                         ret = prh[port].LowerBound * 0.25f + prh[port].UpperBound * 0.75f;
 204                         bounds_given = true;
 205                         sr_scaling = true;
 206                         earlier_hint = true;
 207                 }
 208                 else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(prh[port].HintDescriptor)) {
 209                         ret = prh[port].UpperBound;
 210                         bounds_given = true;
 211                         sr_scaling = true;
 212                         earlier_hint = true;
 213                 }
 214                 else if (LADSPA_IS_HINT_DEFAULT_0(prh[port].HintDescriptor)) {
 215                         ret = 0.0f;
 216                         earlier_hint = true;
 217                 }
 218                 else if (LADSPA_IS_HINT_DEFAULT_1(prh[port].HintDescriptor)) {
 219                         ret = 1.0f;
 220                         earlier_hint = true;
 221                 }
 222                 else if (LADSPA_IS_HINT_DEFAULT_100(prh[port].HintDescriptor)) {
 223                         ret = 100.0f;
 224                         earlier_hint = true;
 225                 }
 226                 else if (LADSPA_IS_HINT_DEFAULT_440(prh[port].HintDescriptor)) {
 227                         ret = 440.0f;
 228                         earlier_hint = true;
 229                 }
 230                 else {
 231                         /* no hint found */
 232                         ret = 0.0f;
 233                 }
 234         }
 235
 236         /* defaults - case 2 */
 237         else if (LADSPA_IS_HINT_BOUNDED_BELOW(prh[port].HintDescriptor) &&
 238                  !LADSPA_IS_HINT_BOUNDED_ABOVE(prh[port].HintDescriptor)) {
 239
 240                 if (prh[port].LowerBound < 0) {
 241                         ret = 0.0f;
 242                 } else {
 243                         ret = prh[port].LowerBound;
 244                 }
 245
 246                 bounds_given = true;
 247                 sr_scaling = true;
 248         }
 249
 250         /* defaults - case 3 */
 251         else if (!LADSPA_IS_HINT_BOUNDED_BELOW(prh[port].HintDescriptor) &&
 252                  LADSPA_IS_HINT_BOUNDED_ABOVE(prh[port].HintDescriptor)) {
 253
 254                 if (prh[port].UpperBound > 0) {
 255                         ret = 0.0f;
 256                 } else {
 257                         ret = prh[port].UpperBound;
 258                 }
 259
 260                 bounds_given = true;
 261                 sr_scaling = true;
 262         }
 263
 264         /* defaults - case 4 */
 265         else if (LADSPA_IS_HINT_BOUNDED_BELOW(prh[port].HintDescriptor) &&
 266                  LADSPA_IS_HINT_BOUNDED_ABOVE(prh[port].HintDescriptor)) {
 267
 268                 if (prh[port].LowerBound < 0 && prh[port].UpperBound > 0) {
 269                         ret = 0.0f;
 270                 } else if (prh[port].LowerBound < 0 && prh[port].UpperBound < 0) {
 271                         ret = prh[port].UpperBound;
 272                 } else {
 273                         ret = prh[port].LowerBound;
 274                 }
 275                 bounds_given = true;
 276                 sr_scaling = true;
 277         }
 278
 279         /* defaults - case 5 */
 280
 281         if (LADSPA_IS_HINT_SAMPLE_RATE(prh[port].HintDescriptor) && !earlier_hint) {
 282                 if (bounds_given) {
 283                         if (sr_scaling) {
 284                                 ret *= _sample_rate;
 285                         }
 286                 } else {
 287                         ret = _sample_rate;
 288                 }
 289         }
 290
 291         return ret;
 292 }
 293
 294 void
 295 LadspaPlugin::set_parameter (uint32_t which, float val)
 296 {
 297         if (which < _descriptor->PortCount) {
 298                 _shadow_data[which] = (LADSPA_Data) val;
 299                 ParameterChanged (which, val); /* EMIT SIGNAL */
 300
 301                 if (which < parameter_count() && controls[which]) {
 302                         controls[which]->Changed ();
 303                 }
 304
 305         } else {
 306                 warning << string_compose (_("illegal parameter number used with plugin \"%1\". This may"
 307                                              "indicate a change in the plugin design, and presets may be"
 308                                              "invalid"), name())
 309                         << endmsg;
 310         }
 311 }
 312
 313 float
 314 LadspaPlugin::get_parameter (uint32_t which) const
 315 {
 316         if (LADSPA_IS_PORT_INPUT(port_descriptor (which))) {
 317                 return (float) _shadow_data[which];
 318         } else {
 319                 return (float) _control_data[which];
 320         }
 321 }
 322
 323 uint32_t
 324 LadspaPlugin::nth_parameter (uint32_t n, bool& ok) const
 325 {
 326         uint32_t x, c;
 327
 328         ok = false;
 329
 330         for (c = 0, x = 0; x < _descriptor->PortCount; ++x) {
 331                 if (LADSPA_IS_PORT_CONTROL (port_descriptor (x))) {
 332                         if (c++ == n) {
 333                                 ok = true;
 334                                 return x;
 335                         }
 336                 }
 337         }
 338         return 0;
 339 }
 340
 341 XMLNode&
 342 LadspaPlugin::get_state()
 343 {
 344         XMLNode *root = new XMLNode(state_node_name());
 345         XMLNode *child;
 346         char buf[16];
 347         LocaleGuard lg (X_("POSIX"));
 348
 349         for (uint32_t i = 0; i < parameter_count(); ++i){
 350
 351                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) &&
 352                     LADSPA_IS_PORT_CONTROL(port_descriptor (i))){
 353
 354                         child = new XMLNode("port");
 355                         snprintf(buf, sizeof(buf), "%u", i);
 356                         child->add_property("number", string(buf));
 357                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
 358                         child->add_property("value", string(buf));
 359                         root->add_child_nocopy (*child);
 360
 361                         if (i < controls.size() && controls[i]) {
 362                                 root->add_child_nocopy (controls[i]->get_state());
 363                         }
 364                 }
 365         }
 366
 367         return *root;
 368 }
 369
 370 bool
 371 LadspaPlugin::save_preset (string name)
 372 {
 373         return Plugin::save_preset (name, "ladspa");
 374 }
 375
 376 int
 377 LadspaPlugin::set_state(const XMLNode& node)
 378 {
 379         XMLNodeList nodes;
 380         XMLProperty *prop;
 381         XMLNodeConstIterator iter;
 382         XMLNode *child;
 383         const char *port;
 384         const char *data;
 385         uint32_t port_id;
 386         LocaleGuard lg (X_("POSIX"));
 387
 388         if (node.name() != state_node_name()) {
 389                 error << _("Bad node sent to LadspaPlugin::set_state") << endmsg;
 390                 return -1;
 391         }
 392
 393         nodes = node.children ("port");
 394
 395         for(iter = nodes.begin(); iter != nodes.end(); ++iter){
 396
 397                 child = *iter;
 398
 399                 if ((prop = child->property("number")) != 0) {
 400                         port = prop->value().c_str();
 401                 } else {
 402                         warning << _("LADSPA: no ladspa port number") << endmsg;
 403                         continue;
 404                 }
 405
 406                 if ((prop = child->property("value")) != 0) {
 407                         data = prop->value().c_str();
 408                 } else {
 409                         warning << _("LADSPA: no ladspa port data") << endmsg;
 410                         continue;
 411                 }
 412
 413                 sscanf (port, "%" PRIu32, &port_id);
 414                 set_parameter (port_id, atof(data));
 415         }
 416
 417         latency_compute_run ();
 418
 419         return 0;
 420 }
 421
 422 int
 423 LadspaPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
 424 {
 425         LADSPA_PortRangeHint prh;
 426
 427         prh  = port_range_hints()[which];
 428
 429
 430         if (LADSPA_IS_HINT_BOUNDED_BELOW(prh.HintDescriptor)) {
 431                 desc.min_unbound = false;
 432                 if (LADSPA_IS_HINT_SAMPLE_RATE(prh.HintDescriptor)) {
 433                         desc.lower = prh.LowerBound * _session.frame_rate();
 434                 } else {
 435                         desc.lower = prh.LowerBound;
 436                 }
 437         } else {
 438                 desc.min_unbound = true;
 439                 desc.lower = 0;
 440         }
 441
 442
 443         if (LADSPA_IS_HINT_BOUNDED_ABOVE(prh.HintDescriptor)) {
 444                 desc.max_unbound = false;
 445                 if (LADSPA_IS_HINT_SAMPLE_RATE(prh.HintDescriptor)) {
 446                         desc.upper = prh.UpperBound * _session.frame_rate();
 447                 } else {
 448                         desc.upper = prh.UpperBound;
 449                 }
 450         } else {
 451                 desc.max_unbound = true;
 452                 desc.upper = 4; /* completely arbitrary */
 453         }
 454
 455         if (LADSPA_IS_HINT_INTEGER (prh.HintDescriptor)) {
 456                 desc.step = 1.0;
 457                 desc.smallstep = 0.1;
 458                 desc.largestep = 10.0;
 459         } else {
 460                 float delta = desc.upper - desc.lower;
 461                 desc.step = delta / 1000.0f;
 462                 desc.smallstep = delta / 10000.0f;
 463                 desc.largestep = delta/10.0f;
 464         }
 465
 466         desc.toggled = LADSPA_IS_HINT_TOGGLED (prh.HintDescriptor);
 467         desc.logarithmic = LADSPA_IS_HINT_LOGARITHMIC (prh.HintDescriptor);
 468         desc.sr_dependent = LADSPA_IS_HINT_SAMPLE_RATE (prh.HintDescriptor);
 469         desc.integer_step = LADSPA_IS_HINT_INTEGER (prh.HintDescriptor);
 470
 471         desc.label = port_names()[which];
 472
 473         return 0;
 474 }
 475
 476
 477 string
 478 LadspaPlugin::describe_parameter (uint32_t which)
 479 {
 480         if (which < parameter_count()) {
 481                 return port_names()[which];
 482         } else {
 483                 return "??";
 484         }
 485 }
 486
 487 nframes_t
 488 LadspaPlugin::latency () const
 489 {
 490         if (_latency_control_port) {
 491                 return (nframes_t) floor (*_latency_control_port);
 492         } else {
 493                 return 0;
 494         }
 495 }
 496
 497 set<uint32_t>
 498 LadspaPlugin::automatable () const
 499 {
 500         set<uint32_t> ret;
 501
 502         for (uint32_t i = 0; i < parameter_count(); ++i){
 503                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) &&
 504                     LADSPA_IS_PORT_CONTROL(port_descriptor (i))){
 505
 506                         ret.insert (ret.end(), i);
 507                 }
 508         }
 509
 510         return ret;
 511 }
 512
 513 int
 514 LadspaPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, int32_t& in_index, int32_t& out_index, nframes_t nframes, nframes_t offset)
 515 {
 516         uint32_t port_index;
 517         cycles_t then, now;
 518
 519         port_index = 0;
 520
 521         then = get_cycles ();
 522
 523         while (port_index < parameter_count()) {
 524                 if (LADSPA_IS_PORT_AUDIO (port_descriptor(port_index))) {
 525                         if (LADSPA_IS_PORT_INPUT (port_descriptor(port_index))) {
 526                                 connect_port (port_index, bufs[min((uint32_t) in_index,nbufs - 1)] + offset);
 527                                 //cerr << this << ' ' << name() << " @ " << offset << " inport " << in_index << " = buf "
 528                                 //     << min((uint32_t)in_index,nbufs) << " = " << &bufs[min((uint32_t)in_index,nbufs)][offset] << endl;
 529                                 in_index++;
 530
 531
 532                         } else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index))) {
 533                                 connect_port (port_index, bufs[min((uint32_t) out_index,nbufs - 1)] + offset);
 534                                 // cerr << this << ' ' << name() << " @ " << offset << " outport " << out_index << " = buf "
 535                                 //     << min((uint32_t)out_index,nbufs) << " = " << &bufs[min((uint32_t)out_index,nbufs)][offset] << endl;
 536                                 out_index++;
 537                         }
 538                 }
 539                 port_index++;
 540         }
 541
 542         run (nframes);
 543         now = get_cycles ();
 544         set_cycles ((uint32_t) (now - then));
 545
 546         return 0;
 547 }
 548
 549 bool
 550 LadspaPlugin::parameter_is_control (uint32_t param) const
 551 {
 552         return LADSPA_IS_PORT_CONTROL(port_descriptor (param));
 553 }
 554
 555 bool
 556 LadspaPlugin::parameter_is_audio (uint32_t param) const
 557 {
 558         return LADSPA_IS_PORT_AUDIO(port_descriptor (param));
 559 }
 560
 561 bool
 562 LadspaPlugin::parameter_is_output (uint32_t param) const
 563 {
 564         return LADSPA_IS_PORT_OUTPUT(port_descriptor (param));
 565 }
 566
 567 bool
 568 LadspaPlugin::parameter_is_input (uint32_t param) const
 569 {
 570         return LADSPA_IS_PORT_INPUT(port_descriptor (param));
 571 }
 572
 573 void
 574 LadspaPlugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
 575 {
 576         if (buf && len) {
 577                 if (param < parameter_count()) {
 578                         snprintf (buf, len, "%.3f", get_parameter (param));
 579                 } else {
 580                         strcat (buf, "0");
 581                 }
 582         }
 583 }
 584
 585 void
 586 LadspaPlugin::run (nframes_t nframes)
 587 {
 588         for (uint32_t i = 0; i < parameter_count(); ++i) {
 589                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) && LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
 590                         _control_data[i] = _shadow_data[i];
 591                 }
 592         }
 593         _descriptor->run (_handle, nframes);
 594 }
 595
 596 void
 597 LadspaPlugin::latency_compute_run ()
 598 {
 599         if (!_latency_control_port) {
 600                 return;
 601         }
 602
 603         /* we need to run the plugin so that it can set its latency
 604            parameter.
 605         */
 606
 607         activate ();
 608
 609         uint32_t port_index = 0;
 610         uint32_t in_index = 0;
 611         uint32_t out_index = 0;
 612         const nframes_t bufsize = 1024;
 613         LADSPA_Data buffer[bufsize];
 614
 615         memset(buffer,0,sizeof(LADSPA_Data)*bufsize);
 616
 617         /* Note that we've already required that plugins
 618            be able to handle in-place processing.
 619         */
 620
 621         port_index = 0;
 622
 623         while (port_index < parameter_count()) {
 624                 if (LADSPA_IS_PORT_AUDIO (port_descriptor (port_index))) {
 625                         if (LADSPA_IS_PORT_INPUT (port_descriptor (port_index))) {
 626                                 connect_port (port_index, buffer);
 627                                 in_index++;
 628                         } else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index))) {
 629                                 connect_port (port_index, buffer);
 630                                 out_index++;
 631                         }
 632                 }
 633                 port_index++;
 634         }
 635
 636         run (bufsize);
 637         deactivate ();
 638 }
 639
 640 PluginPtr
 641 LadspaPluginInfo::load (Session& session)
 642 {
 643         try {
 644                 PluginPtr plugin;
 645                 void *module;
 646
 647                 if ((module = dlopen (path.c_str(), RTLD_NOW)) == 0) {
 648                         error << string_compose(_("LADSPA: cannot load module from \"%1\""), path) << endmsg;
 649                         error << dlerror() << endmsg;
 650                 } else {
 651                         plugin.reset (new LadspaPlugin (module, session.engine(), session, index, session.frame_rate()));
 652                 }
 653
 654                 plugin->set_info(PluginInfoPtr(new LadspaPluginInfo(*this)));
 655                 return plugin;
 656         }
 657
 658         catch (failed_constructor &err) {
 659                 return PluginPtr ((Plugin*) 0);
 660         }
 661 }