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