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