libs/ardour/lv2_plugin.cc

   1 /*
   2     Copyright (C) 2008 Paul Davis
   3     Author: Dave Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <vector>
  22 #include <string>
  23
  24 #include <cstdlib>
  25 #include <cmath>
  26 #include <cstring>
  27
  28 #include <pbd/compose.h>
  29 #include <pbd/error.h>
  30 #include <pbd/pathscanner.h>
  31 #include <pbd/xml++.h>
  32
  33 #include <ardour/ardour.h>
  34 #include <ardour/session.h>
  35 #include <ardour/audioengine.h>
  36 #include <ardour/lv2_plugin.h>
  37
  38 #include <pbd/stl_delete.h>
  39
  40 #include "i18n.h"
  41 #include <locale.h>
  42
  43 using namespace std;
  44 using namespace ARDOUR;
  45 using namespace PBD;
  46
  47 LV2Plugin::LV2Plugin (AudioEngine& e, Session& session, LV2World& world, SLV2Plugin plugin, nframes_t rate)
  48         : Plugin (e, session)
  49         , _world(world)
  50 {
  51         init (world, plugin, rate);
  52 }
  53
  54 LV2Plugin::LV2Plugin (const LV2Plugin &other)
  55         : Plugin (other)
  56         , _world(other._world)
  57 {
  58         init (other._world, other._plugin, other._sample_rate);
  59
  60         for (uint32_t i = 0; i < parameter_count(); ++i) {
  61                 _control_data[i] = other._shadow_data[i];
  62                 _shadow_data[i] = other._shadow_data[i];
  63         }
  64 }
  65
  66 void
  67 LV2Plugin::init (LV2World& world, SLV2Plugin plugin, nframes_t rate)
  68 {
  69         _world = world;
  70         _plugin = plugin;
  71         _ui = NULL;
  72         _control_data = 0;
  73         _shadow_data = 0;
  74         _latency_control_port = 0;
  75         _was_activated = false;
  76
  77         _instance = slv2_plugin_instantiate(plugin, rate, NULL);
  78         _name = slv2_plugin_get_name(plugin);
  79         assert(_name);
  80         _author = slv2_plugin_get_author_name(plugin);
  81
  82         if (_instance == 0) {
  83                 error << _("LV2: Failed to instantiate plugin ") << slv2_plugin_get_uri(plugin) << endl;
  84                 throw failed_constructor();
  85         }
  86
  87         if (slv2_plugin_has_feature(plugin, world.in_place_broken)) {
  88                 error << string_compose(_("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
  89                                 slv2_value_as_string(_name));
  90                 slv2_value_free(_name);
  91                 slv2_value_free(_author);
  92                 throw failed_constructor();
  93         }
  94
  95         _sample_rate = rate;
  96
  97         const uint32_t num_ports = slv2_plugin_get_num_ports(plugin);
  98
  99         _control_data = new float[num_ports];
 100         _shadow_data = new float[num_ports];
 101         _defaults = new float[num_ports];
 102
 103         const bool latent = slv2_plugin_has_latency(plugin);
 104         uint32_t latency_port = (latent ? slv2_plugin_get_latency_port_index(plugin) : 0);
 105
 106         for (uint32_t i = 0; i < num_ports; ++i) {
 107                 if (parameter_is_control(i)) {
 108                         SLV2Port port = slv2_plugin_get_port_by_index(plugin, i);
 109                         SLV2Value def;
 110                         slv2_port_get_range(plugin, port, &def, NULL, NULL);
 111                         _defaults[i] = def ? slv2_value_as_float(def) : 0.0f;
 112                         slv2_value_free(def);
 113
 114                         slv2_instance_connect_port (_instance, i, &_control_data[i]);
 115
 116                         if (latent && i == latency_port) {
 117                                 _latency_control_port = &_control_data[i];
 118                                 *_latency_control_port = 0;
 119                         }
 120
 121                         if (parameter_is_input(i)) {
 122                                 _shadow_data[i] = default_value (i);
 123                         }
 124                 } else {
 125                         _defaults[i] = 0.0f;
 126                 }
 127         }
 128
 129         SLV2UIs uis = slv2_plugin_get_uis(_plugin);
 130         if (slv2_uis_size(uis) > 0) {
 131                 for (unsigned i=0; i < slv2_uis_size(uis); ++i) {
 132                         SLV2UI ui = slv2_uis_get_at(uis, i);
 133                         if (slv2_ui_is_a(ui, _world.gtk_gui)) {
 134                                 _ui = ui;
 135                                 break;
 136                         }
 137                 }
 138         }
 139
 140         Plugin::setup_controls ();
 141
 142         latency_compute_run ();
 143 }
 144
 145 LV2Plugin::~LV2Plugin ()
 146 {
 147         deactivate ();
 148         cleanup ();
 149
 150         GoingAway (); /* EMIT SIGNAL */
 151
 152         slv2_instance_free(_instance);
 153         slv2_value_free(_name);
 154         slv2_value_free(_author);
 155
 156         if (_control_data) {
 157                 delete [] _control_data;
 158         }
 159
 160         if (_shadow_data) {
 161                 delete [] _shadow_data;
 162         }
 163 }
 164
 165 string
 166 LV2Plugin::unique_id() const
 167 {
 168         return slv2_value_as_uri(slv2_plugin_get_uri(_plugin));
 169 }
 170
 171
 172 float
 173 LV2Plugin::default_value (uint32_t port)
 174 {
 175         return _defaults[port];
 176 }
 177
 178 void
 179 LV2Plugin::set_parameter (uint32_t which, float val)
 180 {
 181         if (which < slv2_plugin_get_num_ports(_plugin)) {
 182                 _shadow_data[which] = val;
 183                 ParameterChanged (which, val); /* EMIT SIGNAL */
 184
 185                 if (which < parameter_count() && controls[which]) {
 186                         controls[which]->Changed ();
 187                 }
 188
 189         } else {
 190                 warning << string_compose (_("Illegal parameter number used with plugin \"%1\"."
 191                                 "This is a bug in either Ardour or the LV2 plugin (%2)"),
 192                                 name(), unique_id()) << endmsg;
 193         }
 194 }
 195
 196 float
 197 LV2Plugin::get_parameter (uint32_t which) const
 198 {
 199         if (parameter_is_input(which)) {
 200                 return (float) _shadow_data[which];
 201         } else {
 202                 return (float) _control_data[which];
 203         }
 204         return 0.0f;
 205 }
 206
 207 uint32_t
 208 LV2Plugin::nth_parameter (uint32_t n, bool& ok) const
 209 {
 210         uint32_t x, c;
 211
 212         ok = false;
 213
 214         for (c = 0, x = 0; x < slv2_plugin_get_num_ports(_plugin); ++x) {
 215                 if (parameter_is_control (x)) {
 216                         if (c++ == n) {
 217                                 ok = true;
 218                                 return x;
 219                         }
 220                 }
 221         }
 222
 223         return 0;
 224 }
 225
 226 XMLNode&
 227 LV2Plugin::get_state()
 228 {
 229         XMLNode *root = new XMLNode(state_node_name());
 230         XMLNode *child;
 231         char buf[16];
 232         LocaleGuard lg (X_("POSIX"));
 233
 234         for (uint32_t i = 0; i < parameter_count(); ++i){
 235
 236                 if (parameter_is_input(i) && parameter_is_control(i)) {
 237                         child = new XMLNode("port");
 238                         snprintf(buf, sizeof(buf), "%u", i);
 239                         child->add_property("number", string(buf));
 240                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
 241                         child->add_property("value", string(buf));
 242                         root->add_child_nocopy (*child);
 243
 244                         if (i < controls.size() && controls[i]) {
 245                                 root->add_child_nocopy (controls[i]->get_state());
 246                         }
 247                 }
 248         }
 249
 250         return *root;
 251 }
 252
 253 bool
 254 LV2Plugin::save_preset (string name)
 255 {
 256         return Plugin::save_preset (name, "lv2");
 257 }
 258
 259 bool
 260 LV2Plugin::has_editor() const
 261 {
 262         return (_ui != NULL);
 263 }
 264
 265 int
 266 LV2Plugin::set_state(const XMLNode& node)
 267 {
 268         XMLNodeList nodes;
 269         XMLProperty *prop;
 270         XMLNodeConstIterator iter;
 271         XMLNode *child;
 272         const char *port;
 273         const char *data;
 274         uint32_t port_id;
 275         LocaleGuard lg (X_("POSIX"));
 276
 277         if (node.name() != state_node_name()) {
 278                 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
 279                 return -1;
 280         }
 281
 282         nodes = node.children ("port");
 283
 284         for(iter = nodes.begin(); iter != nodes.end(); ++iter){
 285
 286                 child = *iter;
 287
 288                 if ((prop = child->property("number")) != 0) {
 289                         port = prop->value().c_str();
 290                 } else {
 291                         warning << _("LV2: no lv2 port number") << endmsg;
 292                         continue;
 293                 }
 294
 295                 if ((prop = child->property("value")) != 0) {
 296                         data = prop->value().c_str();
 297                 } else {
 298                         warning << _("LV2: no lv2 port data") << endmsg;
 299                         continue;
 300                 }
 301
 302                 sscanf (port, "%" PRIu32, &port_id);
 303                 set_parameter (port_id, atof(data));
 304         }
 305
 306         latency_compute_run ();
 307
 308         return 0;
 309 }
 310
 311 int
 312 LV2Plugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
 313 {
 314         SLV2Port port = slv2_plugin_get_port_by_index(_plugin, which);
 315
 316         SLV2Value def, min, max;
 317         slv2_port_get_range(_plugin, port, &def, &min, &max);
 318
 319     desc.integer_step = slv2_port_has_property(_plugin, port, _world.integer);
 320     desc.toggled = slv2_port_has_property(_plugin, port, _world.toggled);
 321     desc.logarithmic = false; // TODO (LV2 extension)
 322     desc.sr_dependent = slv2_port_has_property(_plugin, port, _world.srate);
 323     desc.label = slv2_value_as_string(slv2_port_get_name(_plugin, port));
 324     desc.lower = min ? slv2_value_as_float(min) : 0.0f;
 325     desc.upper = max ? slv2_value_as_float(max) : 1.0f;
 326     desc.min_unbound = false; // TODO (LV2 extension)
 327     desc.max_unbound = false; // TODO (LV2 extension)
 328
 329         if (desc.integer_step) {
 330                 desc.step = 1.0;
 331                 desc.smallstep = 0.1;
 332                 desc.largestep = 10.0;
 333         } else {
 334                 const float delta = desc.upper - desc.lower;
 335                 desc.step = delta / 1000.0f;
 336                 desc.smallstep = delta / 10000.0f;
 337                 desc.largestep = delta/10.0f;
 338         }
 339
 340         slv2_value_free(def);
 341         slv2_value_free(min);
 342         slv2_value_free(max);
 343
 344         return 0;
 345 }
 346
 347
 348 string
 349 LV2Plugin::describe_parameter (uint32_t which)
 350 {
 351         if (which < parameter_count()) {
 352                 SLV2Value name = slv2_port_get_name(_plugin,
 353                         slv2_plugin_get_port_by_index(_plugin, which));
 354                 string ret(slv2_value_as_string(name));
 355                 slv2_value_free(name);
 356                 return ret;
 357         } else {
 358                 return "??";
 359         }
 360 }
 361
 362 nframes_t
 363 LV2Plugin::latency () const
 364 {
 365         if (_latency_control_port) {
 366                 return (nframes_t) floor (*_latency_control_port);
 367         } else {
 368                 return 0;
 369         }
 370 }
 371
 372 set<uint32_t>
 373 LV2Plugin::automatable () const
 374 {
 375         set<uint32_t> ret;
 376
 377         for (uint32_t i = 0; i < parameter_count(); ++i){
 378                 if (parameter_is_input(i) && parameter_is_control(i)) {
 379                         ret.insert (ret.end(), i);
 380                 }
 381         }
 382
 383         return ret;
 384 }
 385
 386 int
 387 LV2Plugin::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, int32_t& in_index, int32_t& out_index, nframes_t nframes, nframes_t offset)
 388 {
 389         uint32_t port_index;
 390         cycles_t then, now;
 391
 392         port_index = 0;
 393
 394         then = get_cycles ();
 395
 396         while (port_index < parameter_count()) {
 397                 if (parameter_is_audio(port_index)) {
 398                         if (parameter_is_input(port_index)) {
 399                                 slv2_instance_connect_port(_instance, port_index,
 400                                                 bufs[min((uint32_t)in_index, nbufs - 1)] + offset);
 401                                 in_index++;
 402                         } else if (parameter_is_output(port_index)) {
 403                                 slv2_instance_connect_port(_instance, port_index,
 404                                                 bufs[min((uint32_t)out_index, nbufs - 1)] + offset);
 405                                 out_index++;
 406                         }
 407                 }
 408                 port_index++;
 409         }
 410
 411         run (nframes);
 412         now = get_cycles ();
 413         set_cycles ((uint32_t) (now - then));
 414
 415         return 0;
 416 }
 417
 418 bool
 419 LV2Plugin::parameter_is_control (uint32_t param) const
 420 {
 421         SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
 422         return slv2_port_is_a(_plugin, port, _world.control_class);
 423 }
 424
 425 bool
 426 LV2Plugin::parameter_is_audio (uint32_t param) const
 427 {
 428         SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
 429         return slv2_port_is_a(_plugin, port, _world.audio_class);
 430 }
 431
 432 bool
 433 LV2Plugin::parameter_is_output (uint32_t param) const
 434 {
 435         SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
 436         return slv2_port_is_a(_plugin, port, _world.output_class);
 437 }
 438
 439 bool
 440 LV2Plugin::parameter_is_input (uint32_t param) const
 441 {
 442         SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
 443         return slv2_port_is_a(_plugin, port, _world.input_class);
 444 }
 445
 446 void
 447 LV2Plugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
 448 {
 449         if (buf && len) {
 450                 if (param < parameter_count()) {
 451                         snprintf (buf, len, "%.3f", get_parameter (param));
 452                 } else {
 453                         strcat (buf, "0");
 454                 }
 455         }
 456 }
 457
 458 void
 459 LV2Plugin::run (nframes_t nframes)
 460 {
 461         for (uint32_t i = 0; i < parameter_count(); ++i) {
 462                 if (parameter_is_control(i) && parameter_is_input(i))  {
 463                         _control_data[i] = _shadow_data[i];
 464                 }
 465         }
 466
 467         slv2_instance_run(_instance, nframes);
 468 }
 469
 470 void
 471 LV2Plugin::latency_compute_run ()
 472 {
 473         if (!_latency_control_port) {
 474                 return;
 475         }
 476
 477         /* we need to run the plugin so that it can set its latency
 478            parameter.
 479         */
 480
 481         activate ();
 482
 483         uint32_t port_index = 0;
 484         uint32_t in_index = 0;
 485         uint32_t out_index = 0;
 486         const nframes_t bufsize = 1024;
 487         float buffer[bufsize];
 488
 489         memset(buffer,0,sizeof(float)*bufsize);
 490
 491         /* Note that we've already required that plugins
 492            be able to handle in-place processing.
 493         */
 494
 495         port_index = 0;
 496
 497         while (port_index < parameter_count()) {
 498                 if (parameter_is_audio (port_index)) {
 499                         if (parameter_is_input (port_index)) {
 500                                 slv2_instance_connect_port (_instance, port_index, buffer);
 501                                 in_index++;
 502                         } else if (parameter_is_output (port_index)) {
 503                                 slv2_instance_connect_port (_instance, port_index, buffer);
 504                                 out_index++;
 505                         }
 506                 }
 507                 port_index++;
 508         }
 509
 510         run (bufsize);
 511         deactivate ();
 512 }
 513
 514 LV2World::LV2World()
 515         : world(slv2_world_new())
 516 {
 517         slv2_world_load_all(world);
 518         input_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_INPUT);
 519         output_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_OUTPUT);
 520         control_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_CONTROL);
 521         audio_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_AUDIO);
 522         in_place_broken = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "inPlaceBroken");
 523         integer = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "integer");
 524         toggled = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "toggled");
 525         srate = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "sampleRate");
 526         gtk_gui = slv2_value_new_uri(world, "http://lv2plug.in/ns/extensions/ui#GtkUI");
 527 }
 528
 529 LV2World::~LV2World()
 530 {
 531         slv2_value_free(input_class);
 532         slv2_value_free(output_class);
 533         slv2_value_free(control_class);
 534         slv2_value_free(audio_class);
 535         slv2_value_free(in_place_broken);
 536 }
 537
 538 LV2PluginInfo::LV2PluginInfo (void* lv2_world, void* slv2_plugin)
 539         : _lv2_world(lv2_world)
 540         , _slv2_plugin(slv2_plugin)
 541 {
 542 }
 543
 544 LV2PluginInfo::~LV2PluginInfo()
 545 {
 546 }
 547
 548 PluginPtr
 549 LV2PluginInfo::load (Session& session)
 550 {
 551         try {
 552                 PluginPtr plugin;
 553
 554                 plugin.reset (new LV2Plugin (session.engine(), session,
 555                                 *(LV2World*)_lv2_world, (SLV2Plugin)_slv2_plugin, session.frame_rate()));
 556
 557                 plugin->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
 558                 return plugin;
 559         }
 560
 561         catch (failed_constructor &err) {
 562                 return PluginPtr ((Plugin*) 0);
 563         }
 564
 565         return PluginPtr();
 566 }
 567
 568 PluginInfoList
 569 LV2PluginInfo::discover (void* lv2_world)
 570 {
 571         PluginInfoList plugs;
 572
 573         LV2World* world = (LV2World*)lv2_world;
 574         SLV2Plugins plugins = slv2_world_get_all_plugins(world->world);
 575
 576         for (unsigned i=0; i < slv2_plugins_size(plugins); ++i) {
 577                 SLV2Plugin p = slv2_plugins_get_at(plugins, i);
 578                 LV2PluginInfoPtr info (new LV2PluginInfo(lv2_world, p));
 579
 580                 SLV2Value name = slv2_plugin_get_name(p);
 581                 info->name = string(slv2_value_as_string(name));
 582                 slv2_value_free(name);
 583
 584                 SLV2PluginClass pclass = slv2_plugin_get_class(p);
 585                 SLV2Value label = slv2_plugin_class_get_label(pclass);
 586                 info->category = slv2_value_as_string(label);
 587
 588                 SLV2Value author_name = slv2_plugin_get_author_name(p);
 589                 info->creator = author_name ? string(slv2_value_as_string(author_name)) : "Unknown";
 590                 slv2_value_free(author_name);
 591
 592                 info->path = "/NOPATH"; // Meaningless for LV2
 593
 594                 info->n_inputs = slv2_plugin_get_num_ports_of_class(p,
 595                                 world->input_class, world->audio_class, NULL);
 596
 597                 info->n_outputs = slv2_plugin_get_num_ports_of_class(p,
 598                                 world->output_class, world->audio_class, NULL);
 599
 600                 info->unique_id = slv2_value_as_uri(slv2_plugin_get_uri(p));
 601                 info->index = 0; // Meaningless for LV2
 602
 603                 plugs.push_back (info);
 604         }
 605
 606         return plugs;
 607 }
 608