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                 }
 186
 187                 /* FIXME: add support for logarithmic defaults */
 188
 189                 else if (LADSPA_IS_HINT_DEFAULT_LOW(prh[port].HintDescriptor)) {
 190                         if (LADSPA_IS_HINT_LOGARITHMIC(prh[port].HintDescriptor)) {
 191                                 ret = exp(log(prh[port].LowerBound) * 0.75f + log(prh[port].UpperBound) * 0.25f);
 192                         }
 193                         else {
 194                                 ret = prh[port].LowerBound * 0.75f + prh[port].UpperBound * 0.25f;
 195                         }
 196                         bounds_given = true;
 197                         sr_scaling = true;
 198                 }
 199                 else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(prh[port].HintDescriptor)) {
 200                         if (LADSPA_IS_HINT_LOGARITHMIC(prh[port].HintDescriptor)) {
 201                                 ret = exp(log(prh[port].LowerBound) * 0.5f + log(prh[port].UpperBound) * 0.5f);
 202                         }
 203                         else {
 204                                 ret = prh[port].LowerBound * 0.5f + prh[port].UpperBound * 0.5f;
 205                         }
 206                         bounds_given = true;
 207                         sr_scaling = true;
 208                 }
 209                 else if (LADSPA_IS_HINT_DEFAULT_HIGH(prh[port].HintDescriptor)) {
 210                         if (LADSPA_IS_HINT_LOGARITHMIC(prh[port].HintDescriptor)) {
 211                                 ret = exp(log(prh[port].LowerBound) * 0.25f + log(prh[port].UpperBound) * 0.75f);
 212                         }
 213                         else {
 214                                 ret = prh[port].LowerBound * 0.25f + prh[port].UpperBound * 0.75f;
 215                         }
 216                         bounds_given = true;
 217                         sr_scaling = true;
 218                 }
 219                 else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(prh[port].HintDescriptor)) {
 220                         ret = prh[port].UpperBound;
 221                         bounds_given = true;
 222                         sr_scaling = true;
 223                 }
 224                 else if (LADSPA_IS_HINT_DEFAULT_0(prh[port].HintDescriptor)) {
 225                         ret = 0.0f;
 226                         earlier_hint = true;
 227                 }
 228                 else if (LADSPA_IS_HINT_DEFAULT_1(prh[port].HintDescriptor)) {
 229                         ret = 1.0f;
 230                         earlier_hint = true;
 231                 }
 232                 else if (LADSPA_IS_HINT_DEFAULT_100(prh[port].HintDescriptor)) {
 233                         ret = 100.0f;
 234                         earlier_hint = true;
 235                 }
 236                 else if (LADSPA_IS_HINT_DEFAULT_440(prh[port].HintDescriptor)) {
 237                         ret = 440.0f;
 238                         earlier_hint = true;
 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) && !earlier_hint) {
 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                         if (i < controls.size() && controls[i]) {
 372                                 root->add_child_nocopy (controls[i]->get_state());
 373                         }
 374                 }
 375         }
 376
 377         return *root;
 378 }
 379
 380 bool
 381 LadspaPlugin::save_preset (string name)
 382 {
 383         return Plugin::save_preset (name, "ladspa");
 384 }
 385
 386 int
 387 LadspaPlugin::set_state(const XMLNode& node)
 388 {
 389         XMLNodeList nodes;
 390         XMLProperty *prop;
 391         XMLNodeConstIterator iter;
 392         XMLNode *child;
 393         const char *port;
 394         const char *data;
 395         uint32_t port_id;
 396         LocaleGuard lg (X_("POSIX"));
 397
 398         if (node.name() != state_node_name()) {
 399                 error << _("Bad node sent to LadspaPlugin::set_state") << endmsg;
 400                 return -1;
 401         }
 402
 403         nodes = node.children ("port");
 404
 405         for(iter = nodes.begin(); iter != nodes.end(); ++iter){
 406
 407                 child = *iter;
 408
 409                 if ((prop = child->property("number")) != 0) {
 410                         port = prop->value().c_str();
 411                 } else {
 412                         warning << _("LADSPA: no ladspa port number") << endmsg;
 413                         continue;
 414                 }
 415
 416                 if ((prop = child->property("value")) != 0) {
 417                         data = prop->value().c_str();
 418                 } else {
 419                         warning << _("LADSPA: no ladspa port data") << endmsg;
 420                         continue;
 421                 }
 422
 423                 sscanf (port, "%" PRIu32, &port_id);
 424                 set_parameter (port_id, atof(data));
 425         }
 426
 427         latency_compute_run ();
 428
 429         return 0;
 430 }
 431
 432 int
 433 LadspaPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
 434 {
 435         LADSPA_PortRangeHint prh;
 436
 437         prh  = port_range_hints()[which];
 438
 439
 440         if (LADSPA_IS_HINT_BOUNDED_BELOW(prh.HintDescriptor)) {
 441                 desc.min_unbound = false;
 442                 if (LADSPA_IS_HINT_SAMPLE_RATE(prh.HintDescriptor)) {
 443                         desc.lower = prh.LowerBound * _session.frame_rate();
 444                 } else {
 445                         desc.lower = prh.LowerBound;
 446                 }
 447         } else {
 448                 desc.min_unbound = true;
 449                 desc.lower = 0;
 450         }
 451
 452
 453         if (LADSPA_IS_HINT_BOUNDED_ABOVE(prh.HintDescriptor)) {
 454                 desc.max_unbound = false;
 455                 if (LADSPA_IS_HINT_SAMPLE_RATE(prh.HintDescriptor)) {
 456                         desc.upper = prh.UpperBound * _session.frame_rate();
 457                 } else {
 458                         desc.upper = prh.UpperBound;
 459                 }
 460         } else {
 461                 desc.max_unbound = true;
 462                 desc.upper = 4; /* completely arbitrary */
 463         }
 464
 465         if (LADSPA_IS_HINT_INTEGER (prh.HintDescriptor)) {
 466                 desc.step = 1.0;
 467                 desc.smallstep = 0.1;
 468                 desc.largestep = 10.0;
 469         } else {
 470                 float delta = desc.upper - desc.lower;
 471                 desc.step = delta / 1000.0f;
 472                 desc.smallstep = delta / 10000.0f;
 473                 desc.largestep = delta/10.0f;
 474         }
 475
 476         desc.toggled = LADSPA_IS_HINT_TOGGLED (prh.HintDescriptor);
 477         desc.logarithmic = LADSPA_IS_HINT_LOGARITHMIC (prh.HintDescriptor);
 478         desc.sr_dependent = LADSPA_IS_HINT_SAMPLE_RATE (prh.HintDescriptor);
 479         desc.integer_step = LADSPA_IS_HINT_INTEGER (prh.HintDescriptor);
 480
 481         desc.label = port_names()[which];
 482
 483         return 0;
 484 }
 485
 486
 487 string
 488 LadspaPlugin::describe_parameter (uint32_t which)
 489 {
 490         if (which < parameter_count()) {
 491                 return port_names()[which];
 492         } else {
 493                 return "??";
 494         }
 495 }
 496
 497 nframes_t
 498 LadspaPlugin::latency () const
 499 {
 500         if (_latency_control_port) {
 501                 return (nframes_t) floor (*_latency_control_port);
 502         } else {
 503                 return 0;
 504         }
 505 }
 506
 507 set<uint32_t>
 508 LadspaPlugin::automatable () const
 509 {
 510         set<uint32_t> ret;
 511
 512         for (uint32_t i = 0; i < parameter_count(); ++i){
 513                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) &&
 514                     LADSPA_IS_PORT_CONTROL(port_descriptor (i))){
 515
 516                         ret.insert (ret.end(), i);
 517                 }
 518         }
 519
 520         return ret;
 521 }
 522
 523 int
 524 LadspaPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, int32_t& in_index, int32_t& out_index, nframes_t nframes, nframes_t offset)
 525 {
 526         uint32_t port_index;
 527         cycles_t then, now;
 528
 529         port_index = 0;
 530
 531         then = get_cycles ();
 532
 533         while (port_index < parameter_count()) {
 534                 if (LADSPA_IS_PORT_AUDIO (port_descriptor(port_index))) {
 535                         if (LADSPA_IS_PORT_INPUT (port_descriptor(port_index))) {
 536                                 connect_port (port_index, bufs[min((uint32_t) in_index,nbufs - 1)] + offset);
 537                                 //cerr << this << ' ' << name() << " @ " << offset << " inport " << in_index << " = buf "
 538                                 //     << min((uint32_t)in_index,nbufs) << " = " << &bufs[min((uint32_t)in_index,nbufs)][offset] << endl;
 539                                 in_index++;
 540
 541
 542                         } else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index))) {
 543                                 connect_port (port_index, bufs[min((uint32_t) out_index,nbufs - 1)] + offset);
 544                                 // cerr << this << ' ' << name() << " @ " << offset << " outport " << out_index << " = buf "
 545                                 //     << min((uint32_t)out_index,nbufs) << " = " << &bufs[min((uint32_t)out_index,nbufs)][offset] << endl;
 546                                 out_index++;
 547                         }
 548                 }
 549                 port_index++;
 550         }
 551
 552         run (nframes);
 553         now = get_cycles ();
 554         set_cycles ((uint32_t) (now - then));
 555
 556         return 0;
 557 }
 558
 559 bool
 560 LadspaPlugin::parameter_is_control (uint32_t param) const
 561 {
 562         return LADSPA_IS_PORT_CONTROL(port_descriptor (param));
 563 }
 564
 565 bool
 566 LadspaPlugin::parameter_is_audio (uint32_t param) const
 567 {
 568         return LADSPA_IS_PORT_AUDIO(port_descriptor (param));
 569 }
 570
 571 bool
 572 LadspaPlugin::parameter_is_output (uint32_t param) const
 573 {
 574         return LADSPA_IS_PORT_OUTPUT(port_descriptor (param));
 575 }
 576
 577 bool
 578 LadspaPlugin::parameter_is_input (uint32_t param) const
 579 {
 580         return LADSPA_IS_PORT_INPUT(port_descriptor (param));
 581 }
 582
 583 void
 584 LadspaPlugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
 585 {
 586         if (buf && len) {
 587                 if (param < parameter_count()) {
 588                         snprintf (buf, len, "%.3f", get_parameter (param));
 589                 } else {
 590                         strcat (buf, "0");
 591                 }
 592         }
 593 }
 594
 595 void
 596 LadspaPlugin::run (nframes_t nframes)
 597 {
 598         for (uint32_t i = 0; i < parameter_count(); ++i) {
 599                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) && LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
 600                         _control_data[i] = _shadow_data[i];
 601                 }
 602         }
 603         _descriptor->run (_handle, nframes);
 604 }
 605
 606 void
 607 LadspaPlugin::latency_compute_run ()
 608 {
 609         if (!_latency_control_port) {
 610                 return;
 611         }
 612
 613         /* we need to run the plugin so that it can set its latency
 614            parameter.
 615         */
 616
 617         activate ();
 618
 619         uint32_t port_index = 0;
 620         uint32_t in_index = 0;
 621         uint32_t out_index = 0;
 622         const nframes_t bufsize = 1024;
 623         LADSPA_Data buffer[bufsize];
 624
 625         memset(buffer,0,sizeof(LADSPA_Data)*bufsize);
 626
 627         /* Note that we've already required that plugins
 628            be able to handle in-place processing.
 629         */
 630
 631         port_index = 0;
 632
 633         while (port_index < parameter_count()) {
 634                 if (LADSPA_IS_PORT_AUDIO (port_descriptor (port_index))) {
 635                         if (LADSPA_IS_PORT_INPUT (port_descriptor (port_index))) {
 636                                 connect_port (port_index, buffer);
 637                                 in_index++;
 638                         } else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index))) {
 639                                 connect_port (port_index, buffer);
 640                                 out_index++;
 641                         }
 642                 }
 643                 port_index++;
 644         }
 645
 646         run (bufsize);
 647         deactivate ();
 648 }
 649
 650 PluginPtr
 651 LadspaPluginInfo::load (Session& session)
 652 {
 653         try {
 654                 PluginPtr plugin;
 655                 void *module;
 656
 657                 if ((module = dlopen (path.c_str(), RTLD_NOW)) == 0) {
 658                         error << string_compose(_("LADSPA: cannot load module from \"%1\""), path) << endmsg;
 659                         error << dlerror() << endmsg;
 660                 } else {
 661                         plugin.reset (new LadspaPlugin (module, session.engine(), session, index, session.frame_rate()));
 662                 }
 663
 664                 plugin->set_info(PluginInfoPtr(new LadspaPluginInfo(*this)));
 665                 return plugin;
 666         }
 667
 668         catch (failed_constructor &err) {
 669                 return PluginPtr ((Plugin*) 0);
 670         }
 671 }
 672
 673
 674 LadspaPluginInfo::LadspaPluginInfo()
 675 {
 676         type = ARDOUR::LADSPA;
 677 }