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