2 Copyright (C) 2008 Paul Davis
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.
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.
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.
27 #include <pbd/compose.h>
28 #include <pbd/error.h>
29 #include <pbd/pathscanner.h>
30 #include <pbd/xml++.h>
32 #include <ardour/ardour.h>
33 #include <ardour/session.h>
34 #include <ardour/audioengine.h>
35 #include <ardour/lv2_plugin.h>
37 #include <pbd/stl_delete.h>
43 using namespace ARDOUR;
46 LV2Plugin::LV2Plugin (AudioEngine& e, Session& session, LV2World& world, SLV2Plugin plugin, nframes_t rate)
50 init (world, plugin, rate);
53 LV2Plugin::LV2Plugin (const LV2Plugin &other)
55 , _world(other._world)
57 init (other._world, other._plugin, other._sample_rate);
59 for (uint32_t i = 0; i < parameter_count(); ++i) {
60 _control_data[i] = other._shadow_data[i];
61 _shadow_data[i] = other._shadow_data[i];
66 LV2Plugin::init (LV2World& world, SLV2Plugin plugin, nframes_t rate)
72 _latency_control_port = 0;
73 _was_activated = false;
75 _instance = slv2_plugin_instantiate(plugin, rate, NULL);
76 _name = slv2_plugin_get_name(plugin);
78 _author = slv2_plugin_get_author_name(plugin);
81 error << _("LV2: Failed to instantiate plugin ") << slv2_plugin_get_uri(plugin) << endl;
82 throw failed_constructor();
85 if (slv2_plugin_has_feature(plugin, world.in_place_broken)) {
86 error << string_compose(_("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
87 slv2_value_as_string(_name));
88 slv2_value_free(_name);
89 slv2_value_free(_author);
90 throw failed_constructor();
95 const uint32_t num_ports = slv2_plugin_get_num_ports(plugin);
97 _control_data = new float[num_ports];
98 _shadow_data = new float[num_ports];
99 _defaults = new float[num_ports];
101 const bool latent = slv2_plugin_has_latency(plugin);
102 uint32_t latency_port = (latent ? slv2_plugin_get_latency_port_index(plugin) : 0);
104 for (uint32_t i = 0; i < num_ports; ++i) {
105 if (parameter_is_control(i)) {
106 SLV2Port port = slv2_plugin_get_port_by_index(plugin, i);
108 slv2_port_get_range(plugin, port, &def, NULL, NULL);
109 _defaults[i] = def ? slv2_value_as_float(def) : 0.0f;
110 slv2_value_free(def);
112 slv2_instance_connect_port (_instance, i, &_control_data[i]);
114 if (latent && i == latency_port) {
115 _latency_control_port = &_control_data[i];
116 *_latency_control_port = 0;
119 if (parameter_is_input(i)) {
120 _shadow_data[i] = default_value (i);
127 latency_compute_run ();
130 LV2Plugin::~LV2Plugin ()
135 GoingAway (); /* EMIT SIGNAL */
137 slv2_instance_free(_instance);
138 slv2_value_free(_name);
139 slv2_value_free(_author);
142 delete [] _control_data;
146 delete [] _shadow_data;
151 LV2Plugin::unique_id() const
153 return slv2_value_as_uri(slv2_plugin_get_uri(_plugin));
158 LV2Plugin::default_value (uint32_t port)
160 return _defaults[port];
164 LV2Plugin::set_parameter (uint32_t which, float val)
166 if (which < slv2_plugin_get_num_ports(_plugin)) {
167 _shadow_data[which] = val;
169 ParameterChanged (which, val); /* EMIT SIGNAL */
171 if (which < parameter_count() && controls[which]) {
172 controls[which]->Changed ();
177 warning << string_compose (_("Illegal parameter number used with plugin \"%1\"."
178 "This is a bug in either Ardour or the LV2 plugin (%2)"),
179 name(), unique_id()) << endmsg;
184 LV2Plugin::get_parameter (uint32_t which) const
186 if (parameter_is_input(which)) {
187 return (float) _shadow_data[which];
189 return (float) _control_data[which];
195 LV2Plugin::nth_parameter (uint32_t n, bool& ok) const
201 for (c = 0, x = 0; x < slv2_plugin_get_num_ports(_plugin); ++x) {
202 if (parameter_is_control (x)) {
214 LV2Plugin::get_state()
216 XMLNode *root = new XMLNode(state_node_name());
219 LocaleGuard lg (X_("POSIX"));
221 for (uint32_t i = 0; i < parameter_count(); ++i){
223 if (parameter_is_input(i) && parameter_is_control(i)) {
224 child = new XMLNode("port");
225 snprintf(buf, sizeof(buf), "%u", i);
226 child->add_property("number", string(buf));
227 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
228 child->add_property("value", string(buf));
229 root->add_child_nocopy (*child);
231 /*if (i < controls.size() && controls[i]) {
232 root->add_child_nocopy (controls[i]->get_state());
241 LV2Plugin::save_preset (string name)
243 return Plugin::save_preset (name, "lv2");
247 LV2Plugin::set_state(const XMLNode& node)
251 XMLNodeConstIterator iter;
256 LocaleGuard lg (X_("POSIX"));
258 if (node.name() != state_node_name()) {
259 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
263 nodes = node.children ("port");
265 for(iter = nodes.begin(); iter != nodes.end(); ++iter){
269 if ((prop = child->property("number")) != 0) {
270 port = prop->value().c_str();
272 warning << _("LV2: no lv2 port number") << endmsg;
276 if ((prop = child->property("value")) != 0) {
277 data = prop->value().c_str();
279 warning << _("LV2: no lv2 port data") << endmsg;
283 sscanf (port, "%" PRIu32, &port_id);
284 set_parameter (port_id, atof(data));
287 latency_compute_run ();
293 LV2Plugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
295 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, which);
297 SLV2Value def, min, max;
298 slv2_port_get_range(_plugin, port, &def, &min, &max);
300 desc.integer_step = slv2_port_has_property(_plugin, port, _world.integer);
301 desc.toggled = slv2_port_has_property(_plugin, port, _world.toggled);
302 desc.logarithmic = false; // TODO (LV2 extension)
303 desc.sr_dependent = slv2_port_has_property(_plugin, port, _world.srate);
304 desc.label = slv2_value_as_string(slv2_port_get_name(_plugin, port));
305 desc.lower = min ? slv2_value_as_float(min) : 0.0f;
306 desc.upper = max ? slv2_value_as_float(max) : 1.0f;
307 desc.min_unbound = false; // TODO (LV2 extension)
308 desc.max_unbound = false; // TODO (LV2 extension)
310 if (desc.integer_step) {
312 desc.smallstep = 0.1;
313 desc.largestep = 10.0;
315 const float delta = desc.upper - desc.lower;
316 desc.step = delta / 1000.0f;
317 desc.smallstep = delta / 10000.0f;
318 desc.largestep = delta/10.0f;
321 slv2_value_free(def);
322 slv2_value_free(min);
323 slv2_value_free(max);
330 LV2Plugin::describe_parameter (Parameter which)
332 if (which.type() == PluginAutomation && which.id() < parameter_count()) {
333 SLV2Value name = slv2_port_get_name(_plugin,
334 slv2_plugin_get_port_by_index(_plugin, which));
335 string ret(slv2_value_as_string(name));
336 slv2_value_free(name);
344 LV2Plugin::signal_latency () const
346 if (_latency_control_port) {
347 return (nframes_t) floor (*_latency_control_port);
354 LV2Plugin::automatable () const
358 for (uint32_t i = 0; i < parameter_count(); ++i){
359 if (parameter_is_input(i) && parameter_is_control(i)) {
360 ret.insert (ret.end(), Parameter(PluginAutomation, i));
368 LV2Plugin::connect_and_run (BufferSet& bufs, uint32_t& in_index, uint32_t& out_index, nframes_t nframes, nframes_t offset)
375 then = get_cycles ();
377 const uint32_t nbufs = bufs.count().n_audio();
379 while (port_index < parameter_count()) {
380 if (parameter_is_audio(port_index)) {
381 if (parameter_is_input(port_index)) {
382 const size_t index = min(in_index, nbufs - 1);
383 slv2_instance_connect_port(_instance, port_index,
384 bufs.get_audio(index).data(nframes, offset));
386 } else if (parameter_is_output(port_index)) {
387 const size_t index = min(out_index,nbufs - 1);
388 slv2_instance_connect_port(_instance, port_index,
389 bufs.get_audio(index).data(nframes, offset));
398 set_cycles ((uint32_t) (now - then));
404 LV2Plugin::parameter_is_control (uint32_t param) const
406 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
407 return slv2_port_is_a(_plugin, port, _world.control_class);
411 LV2Plugin::parameter_is_audio (uint32_t param) const
413 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
414 return slv2_port_is_a(_plugin, port, _world.audio_class);
418 LV2Plugin::parameter_is_output (uint32_t param) const
420 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
421 return slv2_port_is_a(_plugin, port, _world.output_class);
425 LV2Plugin::parameter_is_input (uint32_t param) const
427 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
428 return slv2_port_is_a(_plugin, port, _world.input_class);
432 LV2Plugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
435 if (param < parameter_count()) {
436 snprintf (buf, len, "%.3f", get_parameter (param));
444 LV2Plugin::run (nframes_t nframes)
446 for (uint32_t i = 0; i < parameter_count(); ++i) {
447 if (parameter_is_control(i) && parameter_is_input(i)) {
448 _control_data[i] = _shadow_data[i];
452 slv2_instance_run(_instance, nframes);
456 LV2Plugin::latency_compute_run ()
458 if (!_latency_control_port) {
462 /* we need to run the plugin so that it can set its latency
468 uint32_t port_index = 0;
469 uint32_t in_index = 0;
470 uint32_t out_index = 0;
471 const nframes_t bufsize = 1024;
472 float buffer[bufsize];
474 memset(buffer,0,sizeof(float)*bufsize);
476 /* Note that we've already required that plugins
477 be able to handle in-place processing.
482 while (port_index < parameter_count()) {
483 if (parameter_is_audio (port_index)) {
484 if (parameter_is_input (port_index)) {
485 slv2_instance_connect_port (_instance, port_index, buffer);
487 } else if (parameter_is_output (port_index)) {
488 slv2_instance_connect_port (_instance, port_index, buffer);
500 : world(slv2_world_new())
502 slv2_world_load_all(world);
503 input_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_INPUT);
504 output_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_OUTPUT);
505 control_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_CONTROL);
506 audio_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_AUDIO);
507 event_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_EVENT);
508 in_place_broken = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "inPlaceBroken");
509 integer = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "integer");
510 toggled = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "toggled");
511 srate = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "sampleRate");
514 LV2World::~LV2World()
516 slv2_value_free(input_class);
517 slv2_value_free(output_class);
518 slv2_value_free(control_class);
519 slv2_value_free(audio_class);
520 slv2_value_free(event_class);
521 slv2_value_free(in_place_broken);
524 LV2PluginInfo::LV2PluginInfo (void* lv2_world, void* slv2_plugin)
525 : _lv2_world(lv2_world)
526 , _slv2_plugin(slv2_plugin)
530 LV2PluginInfo::~LV2PluginInfo()
535 LV2PluginInfo::load (Session& session)
540 plugin.reset (new LV2Plugin (session.engine(), session,
541 *(LV2World*)_lv2_world, (SLV2Plugin)_slv2_plugin, session.frame_rate()));
543 plugin->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
547 catch (failed_constructor &err) {
548 return PluginPtr ((Plugin*) 0);
555 LV2PluginInfo::discover (void* lv2_world)
557 PluginInfoList plugs;
559 LV2World* world = (LV2World*)lv2_world;
560 SLV2Plugins plugins = slv2_world_get_all_plugins(world->world);
562 for (unsigned i=0; i < slv2_plugins_size(plugins); ++i) {
563 SLV2Plugin p = slv2_plugins_get_at(plugins, i);
564 LV2PluginInfoPtr info (new LV2PluginInfo(lv2_world, p));
566 SLV2Value name = slv2_plugin_get_name(p);
567 info->name = string(slv2_value_as_string(name));
568 slv2_value_free(name);
570 SLV2PluginClass pclass = slv2_plugin_get_class(p);
571 SLV2Value label = slv2_plugin_class_get_label(pclass);
572 info->category = slv2_value_as_string(label);
574 SLV2Value author_name = slv2_plugin_get_author_name(p);
575 info->creator = author_name ? string(slv2_value_as_string(author_name)) : "Unknown";
576 slv2_value_free(author_name);
578 info->path = "/NOPATH"; // Meaningless for LV2
580 info->n_inputs.set_audio(slv2_plugin_get_num_ports_of_class(p,
581 world->input_class, world->audio_class, NULL));
582 info->n_inputs.set_midi(slv2_plugin_get_num_ports_of_class(p,
583 world->input_class, world->event_class, NULL));
585 info->n_outputs.set_audio(slv2_plugin_get_num_ports_of_class(p,
586 world->output_class, world->audio_class, NULL));
587 info->n_outputs.set_midi(slv2_plugin_get_num_ports_of_class(p,
588 world->output_class, world->event_class, NULL));
590 info->unique_id = slv2_value_as_uri(slv2_plugin_get_uri(p));
591 info->index = 0; // Meaningless for LV2
593 plugs.push_back (info);