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 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include <inttypes.h>
  25
  26 #include <vector>
  27 #include <string>
  28
  29 #include <cstdlib>
  30 #include <cstdio> // so libraptor doesn't complain
  31 #include <cmath>
  32 #include <dirent.h>
  33 #include <sys/stat.h>
  34 #include <cerrno>
  35
  36 #ifdef HAVE_LRDF
  37 #include <lrdf.h>
  38 #endif
  39
  40 #include "pbd/compose.h"
  41 #include "pbd/error.h"
  42 #include "pbd/xml++.h"
  43 #include "pbd/stacktrace.h"
  44
  45 #include "midi++/manager.h"
  46
  47 #include "ardour/session.h"
  48 #include "ardour/ladspa_plugin.h"
  49 #include "ardour/buffer_set.h"
  50 #include "ardour/audio_buffer.h"
  51
  52 #include "pbd/stl_delete.h"
  53
  54 #include "i18n.h"
  55 #include <locale.h>
  56
  57 using namespace std;
  58 using namespace ARDOUR;
  59 using namespace PBD;
  60
  61 LadspaPlugin::LadspaPlugin (string module_path, AudioEngine& e, Session& session, uint32_t index, framecnt_t rate)
  62         : Plugin (e, session)
  63 {
  64         init (module_path, index, rate);
  65 }
  66
  67 LadspaPlugin::LadspaPlugin (const LadspaPlugin &other)
  68         : Plugin (other)
  69 {
  70         init (other._module_path, other._index, other._sample_rate);
  71
  72         for (uint32_t i = 0; i < parameter_count(); ++i) {
  73                 _control_data[i] = other._shadow_data[i];
  74                 _shadow_data[i] = other._shadow_data[i];
  75         }
  76 }
  77
  78 void
  79 LadspaPlugin::init (string module_path, uint32_t index, framecnt_t rate)
  80 {
  81         void* func;
  82         LADSPA_Descriptor_Function dfunc;
  83         uint32_t i, port_cnt;
  84
  85         _module_path = module_path;
  86         _module = new Glib::Module(_module_path);
  87         _control_data = 0;
  88         _shadow_data = 0;
  89         _latency_control_port = 0;
  90         _was_activated = false;
  91
  92         if (!(*_module)) {
  93                 error << _("LADSPA: Unable to open module: ") << Glib::Module::get_last_error() << endmsg;
  94                 delete _module;
  95                 throw failed_constructor();
  96         }
  97
  98         if (!_module->get_symbol("ladspa_descriptor", func)) {
  99                 error << _("LADSPA: module has no descriptor function.") << endmsg;
 100                 throw failed_constructor();
 101         }
 102
 103         dfunc = (LADSPA_Descriptor_Function)func;
 104
 105         if ((_descriptor = dfunc (index)) == 0) {
 106                 error << _("LADSPA: plugin has gone away since discovery!") << endmsg;
 107                 throw failed_constructor();
 108         }
 109
 110         _index = index;
 111
 112         if (LADSPA_IS_INPLACE_BROKEN(_descriptor->Properties)) {
 113                 error << string_compose(_("LADSPA: \"%1\" cannot be used, since it cannot do inplace processing"), _descriptor->Name) << endmsg;
 114                 throw failed_constructor();
 115         }
 116
 117         _sample_rate = rate;
 118
 119         if (_descriptor->instantiate == 0) {
 120                 throw failed_constructor();
 121         }
 122
 123         if ((_handle = _descriptor->instantiate (_descriptor, rate)) == 0) {
 124                 throw failed_constructor();
 125         }
 126
 127         port_cnt = parameter_count();
 128
 129         _control_data = new LADSPA_Data[port_cnt];
 130         _shadow_data = new LADSPA_Data[port_cnt];
 131
 132         for (i = 0; i < port_cnt; ++i) {
 133                 if (LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
 134                         connect_port (i, &_control_data[i]);
 135
 136                         if (LADSPA_IS_PORT_OUTPUT(port_descriptor (i)) &&
 137                             strcmp (port_names()[i], X_("latency")) == 0) {
 138                                 _latency_control_port = &_control_data[i];
 139                                 *_latency_control_port = 0;
 140                         }
 141
 142                         if (!LADSPA_IS_PORT_INPUT(port_descriptor (i))) {
 143                                 continue;
 144                         }
 145
 146                         _shadow_data[i] = default_value (i);
 147                 }
 148         }
 149
 150         latency_compute_run ();
 151 }
 152
 153 LadspaPlugin::~LadspaPlugin ()
 154 {
 155         deactivate ();
 156         cleanup ();
 157
 158         // glib has internal reference counting on modules so this is ok
 159         delete _module;
 160
 161         delete [] _control_data;
 162         delete [] _shadow_data;
 163 }
 164
 165 string
 166 LadspaPlugin::unique_id() const
 167 {
 168         char buf[32];
 169         snprintf (buf, sizeof (buf), "%lu", _descriptor->UniqueID);
 170         return string (buf);
 171 }
 172
 173 float
 174 LadspaPlugin::default_value (uint32_t port)
 175 {
 176         const LADSPA_PortRangeHint *prh = port_range_hints();
 177         float ret = 0.0f;
 178         bool bounds_given = false;
 179         bool sr_scaling = false;
 180         bool earlier_hint = false;
 181
 182         /* defaults - case 1 */
 183
 184         if (LADSPA_IS_HINT_HAS_DEFAULT(prh[port].HintDescriptor)) {
 185                 if (LADSPA_IS_HINT_DEFAULT_MINIMUM(prh[port].HintDescriptor)) {
 186                         ret = prh[port].LowerBound;
 187                         bounds_given = true;
 188                         sr_scaling = true;
 189                 }
 190
 191                 else if (LADSPA_IS_HINT_DEFAULT_LOW(prh[port].HintDescriptor)) {
 192                         ret = prh[port].LowerBound * 0.75f + prh[port].UpperBound * 0.25f;
 193                         bounds_given = true;
 194                         sr_scaling = true;
 195                 }
 196                 else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(prh[port].HintDescriptor)) {
 197                         ret = prh[port].LowerBound * 0.5f + prh[port].UpperBound * 0.5f;
 198                         bounds_given = true;
 199                         sr_scaling = true;
 200                 }
 201                 else if (LADSPA_IS_HINT_DEFAULT_HIGH(prh[port].HintDescriptor)) {
 202                         ret = prh[port].LowerBound * 0.25f + prh[port].UpperBound * 0.75f;
 203                         bounds_given = true;
 204                         sr_scaling = true;
 205                 }
 206                 else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(prh[port].HintDescriptor)) {
 207                         ret = prh[port].UpperBound;
 208                         bounds_given = true;
 209                         sr_scaling = true;
 210                 }
 211                 else if (LADSPA_IS_HINT_DEFAULT_0(prh[port].HintDescriptor)) {
 212                         ret = 0.0f;
 213                         earlier_hint = true;
 214                 }
 215                 else if (LADSPA_IS_HINT_DEFAULT_1(prh[port].HintDescriptor)) {
 216                         ret = 1.0f;
 217                         earlier_hint = true;
 218                 }
 219                 else if (LADSPA_IS_HINT_DEFAULT_100(prh[port].HintDescriptor)) {
 220                         ret = 100.0f;
 221                         earlier_hint = true;
 222                 }
 223                 else if (LADSPA_IS_HINT_DEFAULT_440(prh[port].HintDescriptor)) {
 224                         ret = 440.0f;
 225                         earlier_hint = true;
 226                 }
 227                 else {
 228                         /* no hint found */
 229                         ret = 0.0f;
 230                 }
 231         }
 232
 233         /* defaults - case 2 */
 234         else if (LADSPA_IS_HINT_BOUNDED_BELOW(prh[port].HintDescriptor) &&
 235                  !LADSPA_IS_HINT_BOUNDED_ABOVE(prh[port].HintDescriptor)) {
 236
 237                 if (prh[port].LowerBound < 0) {
 238                         ret = 0.0f;
 239                 } else {
 240                         ret = prh[port].LowerBound;
 241                 }
 242
 243                 bounds_given = true;
 244                 sr_scaling = true;
 245         }
 246
 247         /* defaults - case 3 */
 248         else if (!LADSPA_IS_HINT_BOUNDED_BELOW(prh[port].HintDescriptor) &&
 249                  LADSPA_IS_HINT_BOUNDED_ABOVE(prh[port].HintDescriptor)) {
 250
 251                 if (prh[port].UpperBound > 0) {
 252                         ret = 0.0f;
 253                 } else {
 254                         ret = prh[port].UpperBound;
 255                 }
 256
 257                 bounds_given = true;
 258                 sr_scaling = true;
 259         }
 260
 261         /* defaults - case 4 */
 262         else if (LADSPA_IS_HINT_BOUNDED_BELOW(prh[port].HintDescriptor) &&
 263                  LADSPA_IS_HINT_BOUNDED_ABOVE(prh[port].HintDescriptor)) {
 264
 265                 if (prh[port].LowerBound < 0 && prh[port].UpperBound > 0) {
 266                         ret = 0.0f;
 267                 } else if (prh[port].LowerBound < 0 && prh[port].UpperBound < 0) {
 268                         ret = prh[port].UpperBound;
 269                 } else {
 270                         ret = prh[port].LowerBound;
 271                 }
 272                 bounds_given = true;
 273                 sr_scaling = true;
 274         }
 275
 276         /* defaults - case 5 */
 277
 278         if (LADSPA_IS_HINT_SAMPLE_RATE(prh[port].HintDescriptor) && !earlier_hint) {
 279                 if (bounds_given) {
 280                         if (sr_scaling) {
 281                                 ret *= _sample_rate;
 282                         }
 283                 } else {
 284                         ret = _sample_rate;
 285                 }
 286         }
 287
 288         return ret;
 289 }
 290
 291 void
 292 LadspaPlugin::set_parameter (uint32_t which, float val)
 293 {
 294         if (which < _descriptor->PortCount) {
 295
 296                 if (get_parameter (which) == val) {
 297                         return;
 298                 }
 299
 300                 _shadow_data[which] = (LADSPA_Data) val;
 301
 302 #if 0
 303                 if (which < parameter_count() && controls[which]) {
 304                         controls[which]->Changed ();
 305                 }
 306 #endif
 307
 308         } else {
 309                 warning << string_compose (_("illegal parameter number used with plugin \"%1\". This may "
 310                                              "indicate a change in the plugin design, and presets may be "
 311                                              "invalid"), name())
 312                         << endmsg;
 313         }
 314
 315         Plugin::set_parameter (which, val);
 316 }
 317
 318 /** @return `plugin' value */
 319 float
 320 LadspaPlugin::get_parameter (uint32_t which) const
 321 {
 322         if (LADSPA_IS_PORT_INPUT(port_descriptor (which))) {
 323                 return (float) _shadow_data[which];
 324         } else {
 325                 return (float) _control_data[which];
 326         }
 327 }
 328
 329 uint32_t
 330 LadspaPlugin::nth_parameter (uint32_t n, bool& ok) const
 331 {
 332         uint32_t x, c;
 333
 334         ok = false;
 335
 336         for (c = 0, x = 0; x < _descriptor->PortCount; ++x) {
 337                 if (LADSPA_IS_PORT_CONTROL (port_descriptor (x))) {
 338                         if (c++ == n) {
 339                                 ok = true;
 340                                 return x;
 341                         }
 342                 }
 343         }
 344         return 0;
 345 }
 346
 347 void
 348 LadspaPlugin::add_state (XMLNode* root) const
 349 {
 350         XMLNode *child;
 351         char buf[16];
 352         LocaleGuard lg (X_("POSIX"));
 353
 354         for (uint32_t i = 0; i < parameter_count(); ++i){
 355
 356                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) &&
 357                     LADSPA_IS_PORT_CONTROL(port_descriptor (i))){
 358
 359                         child = new XMLNode("Port");
 360                         snprintf(buf, sizeof(buf), "%u", i);
 361                         child->add_property("number", string(buf));
 362                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
 363                         child->add_property("value", string(buf));
 364                         root->add_child_nocopy (*child);
 365                 }
 366         }
 367 }
 368
 369 int
 370 LadspaPlugin::set_state (const XMLNode& node, int version)
 371 {
 372         if (version < 3000) {
 373                 return set_state_2X (node, version);
 374         }
 375
 376 #ifndef NO_PLUGIN_STATE
 377         XMLNodeList nodes;
 378         XMLProperty *prop;
 379         XMLNodeConstIterator iter;
 380         XMLNode *child;
 381         const char *port;
 382         const char *data;
 383         uint32_t port_id;
 384 #endif
 385         LocaleGuard lg (X_("POSIX"));
 386
 387         if (node.name() != state_node_name()) {
 388                 error << _("Bad node sent to LadspaPlugin::set_state") << endmsg;
 389                 return -1;
 390         }
 391
 392 #ifndef NO_PLUGIN_STATE
 393
 394         nodes = node.children ("Port");
 395
 396         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
 397
 398                 child = *iter;
 399
 400                 if ((prop = child->property("number")) != 0) {
 401                         port = prop->value().c_str();
 402                 } else {
 403                         warning << _("LADSPA: no ladspa port number") << endmsg;
 404                         continue;
 405                 }
 406                 if ((prop = child->property("value")) != 0) {
 407                         data = prop->value().c_str();
 408                 } else {
 409                         warning << _("LADSPA: no ladspa port data") << endmsg;
 410                         continue;
 411                 }
 412
 413                 sscanf (port, "%" PRIu32, &port_id);
 414                 set_parameter (port_id, atof(data));
 415         }
 416 #endif
 417
 418         latency_compute_run ();
 419
 420         return Plugin::set_state (node, version);
 421 }
 422
 423 int
 424 LadspaPlugin::set_state_2X (const XMLNode& node, int /* version */)
 425 {
 426 #ifndef NO_PLUGIN_STATE
 427         XMLNodeList nodes;
 428         XMLProperty *prop;
 429         XMLNodeConstIterator iter;
 430         XMLNode *child;
 431         const char *port;
 432         const char *data;
 433         uint32_t port_id;
 434 #endif
 435         LocaleGuard lg (X_("POSIX"));
 436
 437         if (node.name() != state_node_name()) {
 438                 error << _("Bad node sent to LadspaPlugin::set_state") << endmsg;
 439                 return -1;
 440         }
 441
 442 #ifndef NO_PLUGIN_STATE
 443         nodes = node.children ("port");
 444
 445         for(iter = nodes.begin(); iter != nodes.end(); ++iter){
 446
 447                 child = *iter;
 448
 449                 if ((prop = child->property("number")) != 0) {
 450                         port = prop->value().c_str();
 451                 } else {
 452                         warning << _("LADSPA: no ladspa port number") << endmsg;
 453                         continue;
 454                 }
 455                 if ((prop = child->property("value")) != 0) {
 456                         data = prop->value().c_str();
 457                 } else {
 458                         warning << _("LADSPA: no ladspa port data") << endmsg;
 459                         continue;
 460                 }
 461
 462                 sscanf (port, "%" PRIu32, &port_id);
 463                 set_parameter (port_id, atof(data));
 464         }
 465
 466         latency_compute_run ();
 467 #endif
 468
 469         return 0;
 470 }
 471
 472 int
 473 LadspaPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
 474 {
 475         LADSPA_PortRangeHint prh;
 476
 477         prh  = port_range_hints()[which];
 478
 479
 480         if (LADSPA_IS_HINT_BOUNDED_BELOW(prh.HintDescriptor)) {
 481                 desc.min_unbound = false;
 482                 if (LADSPA_IS_HINT_SAMPLE_RATE(prh.HintDescriptor)) {
 483                         desc.lower = prh.LowerBound * _session.frame_rate();
 484                 } else {
 485                         desc.lower = prh.LowerBound;
 486                 }
 487         } else {
 488                 desc.min_unbound = true;
 489                 desc.lower = 0;
 490         }
 491
 492
 493         if (LADSPA_IS_HINT_BOUNDED_ABOVE(prh.HintDescriptor)) {
 494                 desc.max_unbound = false;
 495                 if (LADSPA_IS_HINT_SAMPLE_RATE(prh.HintDescriptor)) {
 496                         desc.upper = prh.UpperBound * _session.frame_rate();
 497                 } else {
 498                         desc.upper = prh.UpperBound;
 499                 }
 500         } else {
 501                 desc.max_unbound = true;
 502                 desc.upper = 4; /* completely arbitrary */
 503         }
 504
 505         if (LADSPA_IS_HINT_INTEGER (prh.HintDescriptor)) {
 506                 desc.step = 1.0;
 507                 desc.smallstep = 0.1;
 508                 desc.largestep = 10.0;
 509         } else {
 510                 float delta = desc.upper - desc.lower;
 511                 desc.step = delta / 1000.0f;
 512                 desc.smallstep = delta / 10000.0f;
 513                 desc.largestep = delta/10.0f;
 514         }
 515
 516         desc.toggled = LADSPA_IS_HINT_TOGGLED (prh.HintDescriptor);
 517         desc.logarithmic = LADSPA_IS_HINT_LOGARITHMIC (prh.HintDescriptor);
 518         desc.sr_dependent = LADSPA_IS_HINT_SAMPLE_RATE (prh.HintDescriptor);
 519         desc.integer_step = LADSPA_IS_HINT_INTEGER (prh.HintDescriptor);
 520
 521         desc.label = port_names()[which];
 522
 523         return 0;
 524 }
 525
 526 string
 527 LadspaPlugin::describe_parameter (Evoral::Parameter which)
 528 {
 529         if (which.type() == PluginAutomation && which.id() < parameter_count()) {
 530                 return port_names()[which.id()];
 531         } else {
 532                 return "??";
 533         }
 534 }
 535
 536 ARDOUR::framecnt_t
 537 LadspaPlugin::signal_latency () const
 538 {
 539         if (_user_latency) {
 540                 return _user_latency;
 541         }
 542
 543         if (_latency_control_port) {
 544                 return (framecnt_t) floor (*_latency_control_port);
 545         } else {
 546                 return 0;
 547         }
 548 }
 549
 550 set<Evoral::Parameter>
 551 LadspaPlugin::automatable () const
 552 {
 553         set<Evoral::Parameter> ret;
 554
 555         for (uint32_t i = 0; i < parameter_count(); ++i){
 556                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) &&
 557                     LADSPA_IS_PORT_CONTROL(port_descriptor (i))){
 558
 559                         ret.insert (ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
 560                 }
 561         }
 562
 563         return ret;
 564 }
 565
 566 int
 567 LadspaPlugin::connect_and_run (BufferSet& bufs,
 568                 ChanMapping in_map, ChanMapping out_map,
 569                 pframes_t nframes, framecnt_t offset)
 570 {
 571         Plugin::connect_and_run (bufs, in_map, out_map, nframes, offset);
 572
 573         cycles_t now;
 574         cycles_t then = get_cycles ();
 575
 576         BufferSet& silent_bufs  = _session.get_silent_buffers(ChanCount(DataType::AUDIO, 1));
 577         BufferSet& scratch_bufs = _session.get_silent_buffers(ChanCount(DataType::AUDIO, 1));
 578
 579         uint32_t audio_in_index  = 0;
 580         uint32_t audio_out_index = 0;
 581         bool valid;
 582         for (uint32_t port_index = 0; port_index < parameter_count(); ++port_index) {
 583                 if (LADSPA_IS_PORT_AUDIO(port_descriptor(port_index))) {
 584                         if (LADSPA_IS_PORT_INPUT(port_descriptor(port_index))) {
 585                                 const uint32_t buf_index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
 586                                 connect_port(port_index,
 587                                              valid ? bufs.get_audio(buf_index).data(offset)
 588                                                    : silent_bufs.get_audio(0).data(offset));
 589                         } else if (LADSPA_IS_PORT_OUTPUT(port_descriptor(port_index))) {
 590                                 const uint32_t buf_index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
 591                                 connect_port(port_index,
 592                                              valid ? bufs.get_audio(buf_index).data(offset)
 593                                                    : scratch_bufs.get_audio(0).data(offset));
 594                         }
 595                 }
 596         }
 597
 598         run_in_place (nframes);
 599         now = get_cycles ();
 600         set_cycles ((uint32_t) (now - then));
 601
 602         return 0;
 603 }
 604
 605 bool
 606 LadspaPlugin::parameter_is_control (uint32_t param) const
 607 {
 608         return LADSPA_IS_PORT_CONTROL(port_descriptor (param));
 609 }
 610
 611 bool
 612 LadspaPlugin::parameter_is_audio (uint32_t param) const
 613 {
 614         return LADSPA_IS_PORT_AUDIO(port_descriptor (param));
 615 }
 616
 617 bool
 618 LadspaPlugin::parameter_is_output (uint32_t param) const
 619 {
 620         return LADSPA_IS_PORT_OUTPUT(port_descriptor (param));
 621 }
 622
 623 bool
 624 LadspaPlugin::parameter_is_input (uint32_t param) const
 625 {
 626         return LADSPA_IS_PORT_INPUT(port_descriptor (param));
 627 }
 628
 629 void
 630 LadspaPlugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
 631 {
 632         if (buf && len) {
 633                 if (param < parameter_count()) {
 634                         snprintf (buf, len, "%.3f", get_parameter (param));
 635                 } else {
 636                         strcat (buf, "0");
 637                 }
 638         }
 639 }
 640
 641 boost::shared_ptr<Plugin::ScalePoints>
 642 LadspaPlugin::get_scale_points(uint32_t port_index) const
 643 {
 644         boost::shared_ptr<Plugin::ScalePoints> ret;
 645 #ifdef HAVE_LRDF
 646         const uint32_t id     = atol(unique_id().c_str());
 647         lrdf_defaults* points = lrdf_get_scale_values(id, port_index);
 648
 649         if (!points) {
 650                 return ret;
 651         }
 652
 653         ret = boost::shared_ptr<Plugin::ScalePoints>(new ScalePoints());
 654
 655         for (uint32_t i = 0; i < points->count; ++i) {
 656                 ret->insert(make_pair(points->items[i].label,
 657                                       points->items[i].value));
 658         }
 659
 660         lrdf_free_setting_values(points);
 661 #endif
 662         return ret;
 663 }
 664
 665 void
 666 LadspaPlugin::run_in_place (pframes_t nframes)
 667 {
 668         for (uint32_t i = 0; i < parameter_count(); ++i) {
 669                 if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) && LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
 670                         _control_data[i] = _shadow_data[i];
 671                 }
 672         }
 673
 674         assert (_was_activated);
 675
 676         _descriptor->run (_handle, nframes);
 677 }
 678
 679 void
 680 LadspaPlugin::latency_compute_run ()
 681 {
 682         if (!_latency_control_port) {
 683                 return;
 684         }
 685
 686         /* we need to run the plugin so that it can set its latency
 687            parameter.
 688         */
 689
 690         activate ();
 691
 692         uint32_t port_index = 0;
 693         uint32_t in_index = 0;
 694         uint32_t out_index = 0;
 695         const framecnt_t bufsize = 1024;
 696         LADSPA_Data buffer[bufsize];
 697
 698         memset(buffer,0,sizeof(LADSPA_Data)*bufsize);
 699
 700         /* Note that we've already required that plugins
 701            be able to handle in-place processing.
 702         */
 703
 704         port_index = 0;
 705
 706         while (port_index < parameter_count()) {
 707                 if (LADSPA_IS_PORT_AUDIO (port_descriptor (port_index))) {
 708                         if (LADSPA_IS_PORT_INPUT (port_descriptor (port_index))) {
 709                                 connect_port (port_index, buffer);
 710                                 in_index++;
 711                         } else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index))) {
 712                                 connect_port (port_index, buffer);
 713                                 out_index++;
 714                         }
 715                 }
 716                 port_index++;
 717         }
 718
 719         run_in_place (bufsize);
 720         deactivate ();
 721 }
 722
 723 PluginPtr
 724 LadspaPluginInfo::load (Session& session)
 725 {
 726         try {
 727                 PluginPtr plugin (new LadspaPlugin (path, session.engine(), session, index, session.frame_rate()));
 728                 plugin->set_info(PluginInfoPtr(new LadspaPluginInfo(*this)));
 729                 return plugin;
 730         }
 731
 732         catch (failed_constructor &err) {
 733                 return PluginPtr ((Plugin*) 0);
 734         }
 735 }
 736
 737 LadspaPluginInfo::LadspaPluginInfo()
 738 {
 739        type = ARDOUR::LADSPA;
 740 }
 741
 742
 743 void
 744 LadspaPlugin::find_presets ()
 745 {
 746 #ifdef HAVE_LRDF
 747         uint32_t id;
 748         std::string unique (unique_id());
 749
 750         if (!isdigit (unique[0])) {
 751                 return;
 752         }
 753
 754         id = atol (unique.c_str());
 755
 756         lrdf_uris* set_uris = lrdf_get_setting_uris(id);
 757
 758         if (set_uris) {
 759                 for (uint32_t i = 0; i < (uint32_t) set_uris->count; ++i) {
 760                         if (char* label = lrdf_get_label(set_uris->items[i])) {
 761                                 PresetRecord rec (set_uris->items[i], label);
 762                                 _presets.insert (make_pair (set_uris->items[i], rec));
 763                         }
 764                 }
 765                 lrdf_free_uris(set_uris);
 766         }
 767 #endif
 768 }
 769
 770
 771 bool
 772 LadspaPlugin::load_preset (PresetRecord r)
 773 {
 774 #ifdef HAVE_LRDF
 775         lrdf_defaults* defs = lrdf_get_setting_values (r.uri.c_str());
 776
 777         if (defs) {
 778                 for (uint32_t i = 0; i < (uint32_t) defs->count; ++i) {
 779                         if (parameter_is_input (defs->items[i].pid)) {
 780                                 set_parameter(defs->items[i].pid, defs->items[i].value);
 781                         }
 782                 }
 783                 lrdf_free_setting_values(defs);
 784         }
 785
 786         Plugin::load_preset (r);
 787 #endif
 788         return true;
 789 }
 790
 791 /* XXX: should be in liblrdf */
 792 static void
 793 lrdf_remove_preset (const char* /*source*/, const char *setting_uri)
 794 {
 795 #ifdef HAVE_LRDF
 796         lrdf_statement p;
 797         lrdf_statement *q;
 798         lrdf_statement *i;
 799         char setting_uri_copy[64];
 800         char buf[64];
 801
 802         strncpy(setting_uri_copy, setting_uri, sizeof(setting_uri_copy));
 803
 804         p.subject = setting_uri_copy;
 805         strncpy(buf, LADSPA_BASE "hasPortValue", sizeof(buf));
 806         p.predicate = buf;
 807         p.object = NULL;
 808         q = lrdf_matches(&p);
 809
 810         p.predicate = NULL;
 811         p.object = NULL;
 812         for (i = q; i; i = i->next) {
 813                 p.subject = i->object;
 814                 lrdf_remove_matches(&p);
 815         }
 816
 817         lrdf_free_statements(q);
 818
 819         p.subject = NULL;
 820         strncpy(buf, LADSPA_BASE "hasSetting", sizeof(buf));
 821         p.predicate = buf;
 822         p.object = setting_uri_copy;
 823         lrdf_remove_matches(&p);
 824
 825         p.subject = setting_uri_copy;
 826         p.predicate = NULL;
 827         p.object = NULL;
 828         lrdf_remove_matches (&p);
 829 #endif
 830 }
 831
 832 void
 833 LadspaPlugin::do_remove_preset (string name)
 834 {
 835 #ifdef HAVE_LRDF
 836         string const envvar = preset_envvar ();
 837         if (envvar.empty()) {
 838                 warning << _("Could not locate HOME.  Preset not removed.") << endmsg;
 839                 return;
 840         }
 841
 842         Plugin::PresetRecord const * p = preset_by_label (name);
 843         if (!p) {
 844                 return;
 845         }
 846
 847         string const source = preset_source (envvar);
 848         lrdf_remove_preset (source.c_str(), p->uri.c_str ());
 849
 850         write_preset_file (envvar);
 851 #endif
 852 }
 853
 854 string
 855 LadspaPlugin::preset_envvar () const
 856 {
 857         char* envvar;
 858         if ((envvar = getenv ("HOME")) == 0) {
 859                 return "";
 860         }
 861
 862         return envvar;
 863 }
 864
 865 string
 866 LadspaPlugin::preset_source (string envvar) const
 867 {
 868         return string_compose ("file:%1/.ladspa/rdf/ardour-presets.n3", envvar);
 869 }
 870
 871 bool
 872 LadspaPlugin::write_preset_file (string envvar)
 873 {
 874 #ifdef HAVE_LRDF
 875         string path = string_compose("%1/.ladspa", envvar);
 876         if (g_mkdir_with_parents (path.c_str(), 0775)) {
 877                 warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
 878                 return false;
 879         }
 880
 881         path += "/rdf";
 882         if (g_mkdir_with_parents (path.c_str(), 0775)) {
 883                 warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
 884                 return false;
 885         }
 886
 887         string const source = preset_source (envvar);
 888
 889         if (lrdf_export_by_source (source.c_str(), source.substr(5).c_str())) {
 890                 warning << string_compose(_("Error saving presets file %1."), source) << endmsg;
 891                 return false;
 892         }
 893
 894         return true;
 895 #else
 896         return false;
 897 #endif
 898 }
 899
 900 string
 901 LadspaPlugin::do_save_preset (string name)
 902 {
 903 #ifdef HAVE_LRDF
 904         /* make a vector of pids that are input parameters */
 905         vector<int> input_parameter_pids;
 906         for (uint32_t i = 0; i < parameter_count(); ++i) {
 907                 if (parameter_is_input (i)) {
 908                         input_parameter_pids.push_back (i);
 909                 }
 910         }
 911
 912         std::string unique (unique_id());
 913
 914         if (!isdigit (unique[0])) {
 915                 return "";
 916         }
 917
 918         uint32_t const id = atol (unique.c_str());
 919
 920         lrdf_defaults defaults;
 921         defaults.count = input_parameter_pids.size ();
 922         lrdf_portvalue portvalues[input_parameter_pids.size()];
 923         defaults.items = portvalues;
 924
 925         for (vector<int>::size_type i = 0; i < input_parameter_pids.size(); ++i) {
 926                 portvalues[i].pid = input_parameter_pids[i];
 927                 portvalues[i].value = get_parameter (input_parameter_pids[i]);
 928         }
 929
 930         string const envvar = preset_envvar ();
 931         if (envvar.empty()) {
 932                 warning << _("Could not locate HOME.  Preset not saved.") << endmsg;
 933                 return "";
 934         }
 935
 936         string const source = preset_source (envvar);
 937
 938         char* uri_char = lrdf_add_preset (source.c_str(), name.c_str(), id, &defaults);
 939         string uri (uri_char);
 940         free (uri_char);
 941
 942         if (!write_preset_file (envvar)) {
 943                 return "";
 944         }
 945
 946         return uri;
 947 #else
 948         return string();
 949 #endif
 950 }
 951
 952 LADSPA_PortDescriptor
 953 LadspaPlugin::port_descriptor (uint32_t i) const
 954 {
 955         if (i < _descriptor->PortCount) {
 956                 return _descriptor->PortDescriptors[i];
 957         }
 958
 959         warning << "LADSPA plugin port index " << i << " out of range." << endmsg;
 960         return 0;
 961 }
 962
 963
 964