?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement latest LV2 files extension.
[ardour2.git] / libs / ardour / lv2_plugin.cc
blobf3e30cb78652c0b26eee6437d84c743db3b4d7b8
1 /*
2 Copyright (C) 2008-2011 Paul Davis
3 Author: David 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 <string>
22 #include <vector>
23
24 #include <cmath>
25 #include <cstdlib>
26 #include <cstring>
27
28 #include <glibmm.h>
29
30 #include "pbd/compose.h"
31 #include "pbd/error.h"
32 #include "pbd/pathscanner.h"
33 #include "pbd/xml++.h"
34
35 #include "ardour/ardour.h"
36 #include "ardour/audio_buffer.h"
37 #include "ardour/audioengine.h"
38 #include "ardour/debug.h"
39 #include "ardour/lv2_event_buffer.h"
40 #include "ardour/lv2_plugin.h"
41 #include "ardour/session.h"
42
43 #include "pbd/stl_delete.h"
44
45 #include "i18n.h"
46 #include <locale.h>
47
48 #include "lv2ext/lv2_files.h"
49 #include "lv2ext/lv2_persist.h"
50 #include "rdff.h"
51
52 #define NS_DC "http://dublincore.org/documents/dcmi-namespace/"
53 #define NS_LV2 "http://lv2plug.in/ns/lv2core#"
54 #define NS_PSET "http://lv2plug.in/ns/dev/presets#"
55 #define NS_UI "http://lv2plug.in/ns/extensions/ui#"
56
57 using namespace std;
58 using namespace ARDOUR;
59 using namespace PBD;
60
61 URIMap LV2Plugin::_uri_map;
62 uint32_t LV2Plugin::_midi_event_type = _uri_map.uri_to_id(
63 "http://lv2plug.in/ns/ext/event",
64 "http://lv2plug.in/ns/ext/midi#MidiEvent");
65
66 LV2Plugin::LV2Plugin (AudioEngine& engine,
67 Session& session,
68 LV2World& world,
69 SLV2Plugin plugin,
70 framecnt_t rate)
71 : Plugin(engine, session)
72 , _world(world)
73 , _features(NULL)
74 , _insert_id("0")
75 {
76 init(world, plugin, rate);
77 }
78
79 LV2Plugin::LV2Plugin (const LV2Plugin& other)
80 : Plugin(other)
81 , _world(other._world)
82 , _features(NULL)
83 , _insert_id(other._insert_id)
84 {
85 init(other._world, other._plugin, other._sample_rate);
86
87 for (uint32_t i = 0; i < parameter_count(); ++i) {
88 _control_data[i] = other._shadow_data[i];
89 _shadow_data[i] = other._shadow_data[i];
90 }
91 }
92
93 void
94 LV2Plugin::init(LV2World& world, SLV2Plugin plugin, framecnt_t rate)
95 {
96 DEBUG_TRACE(DEBUG::LV2, "init\n");
97
98 _world = world;
99 _plugin = plugin;
100 _ui = NULL;
101 _control_data = 0;
102 _shadow_data = 0;
103 _latency_control_port = 0;
104 _was_activated = false;
105
106 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
107 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
108 _path_support_feature.URI = LV2_FILES_PATH_SUPPORT_URI;
109 _new_file_support_feature.URI = LV2_FILES_NEW_FILE_SUPPORT_URI;
110 _persist_feature.URI = "http://lv2plug.in/ns/ext/persist";
111 _persist_feature.data = NULL;
112
113 SLV2Value persist_uri = slv2_value_new_uri(_world.world, _persist_feature.URI);
114 _supports_persist = slv2_plugin_has_feature(plugin, persist_uri);
115 slv2_value_free(persist_uri);
116
117 _features = (LV2_Feature**)malloc(sizeof(LV2_Feature*) * 7);
118 _features[0] = &_instance_access_feature;
119 _features[1] = &_data_access_feature;
120 _features[2] = &_path_support_feature;
121 _features[3] = &_new_file_support_feature;
122 _features[4] = &_persist_feature;
123 _features[5] = _uri_map.feature();
124 _features[6] = NULL;
125
126 LV2_Files_Path_Support* path_support = (LV2_Files_Path_Support*)malloc(
127 sizeof(LV2_Files_Path_Support));
128 path_support->host_data = this;
129 path_support->abstract_path = &lv2_files_abstract_path;
130 path_support->absolute_path = &lv2_files_absolute_path;
131 _path_support_feature.data = path_support;
132
133 LV2_Files_New_File_Support* new_file_support = (LV2_Files_New_File_Support*)malloc(
134 sizeof(LV2_Files_New_File_Support));
135 new_file_support->host_data = this;
136 new_file_support->new_file_path = &lv2_files_new_file_path;
137 _new_file_support_feature.data = new_file_support;
138
139 _instance = slv2_plugin_instantiate(plugin, rate, _features);
140 _name = slv2_plugin_get_name(plugin);
141 _author = slv2_plugin_get_author_name(plugin);
142
143 if (_instance == 0) {
144 error << _("LV2: Failed to instantiate plugin ")
145 << slv2_value_as_string(slv2_plugin_get_uri(plugin)) << endmsg;
146 throw failed_constructor();
147 }
148
149 _instance_access_feature.data = (void*)_instance->lv2_handle;
150 _data_access_extension_data.extension_data = _instance->lv2_descriptor->extension_data;
151 _data_access_feature.data = &_data_access_extension_data;
152
153 if (slv2_plugin_has_feature(plugin, world.in_place_broken)) {
154 error << string_compose(
155 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
156 slv2_value_as_string(_name)) << endmsg;
157 slv2_value_free(_name);
158 slv2_value_free(_author);
159 throw failed_constructor();
160 }
161
162 _sample_rate = rate;
163
164 const uint32_t num_ports = slv2_plugin_get_num_ports(plugin);
165 const bool latent = slv2_plugin_has_latency(plugin);
166 const uint32_t latency_port = (latent)
167 ? slv2_plugin_get_latency_port_index(plugin)
168 : 0;
169
170 _control_data = new float[num_ports];
171 _shadow_data = new float[num_ports];
172 _defaults = new float[num_ports];
173
174 for (uint32_t i = 0; i < num_ports; ++i) {
175 SLV2Port port = slv2_plugin_get_port_by_index(plugin, i);
176 SLV2Value sym = slv2_port_get_symbol(_plugin, port);
177
178 // Store index in map so we can look up index by symbol
179 _port_indices.insert(std::make_pair(slv2_value_as_string(sym), i));
180
181 // Get range and default value if applicable
182 if (parameter_is_control(i)) {
183 SLV2Value def;
184 slv2_port_get_range(plugin, port, &def, NULL, NULL);
185 _defaults[i] = def ? slv2_value_as_float(def) : 0.0f;
186 slv2_value_free(def);
187
188 slv2_instance_connect_port(_instance, i, &_control_data[i]);
189
190 if (latent && ( i == latency_port) ) {
191 _latency_control_port = &_control_data[i];
192 *_latency_control_port = 0;
193 }
194
195 if (parameter_is_input(i)) {
196 _shadow_data[i] = default_value(i);
197 }
198 } else {
199 _defaults[i] = 0.0f;
200 }
201 }
202
203 SLV2UIs uis = slv2_plugin_get_uis(_plugin);
204 if (slv2_uis_size(uis) > 0) {
205 // Look for Gtk native UI
206 for (unsigned i = 0; i < slv2_uis_size(uis); ++i) {
207 SLV2UI ui = slv2_uis_get_at(uis, i);
208 if (slv2_ui_is_a(ui, _world.gtk_gui)) {
209 _ui = ui;
210 break;
211 }
212 }
213
214 // If Gtk UI is not available, try to find external UI
215 if (!_ui) {
216 for (unsigned i = 0; i < slv2_uis_size(uis); ++i) {
217 SLV2UI ui = slv2_uis_get_at(uis, i);
218 if (slv2_ui_is_a(ui, _world.external_gui)) {
219 _ui = ui;
220 break;
221 }
222 }
223 }
224 }
225
226 latency_compute_run();
227 }
228
229 LV2Plugin::~LV2Plugin ()
230 {
231 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
232
233 deactivate();
234 cleanup();
235
236 slv2_instance_free(_instance);
237 slv2_value_free(_name);
238 slv2_value_free(_author);
239
240 delete [] _control_data;
241 delete [] _shadow_data;
242 }
243
244 bool
245 LV2Plugin::is_external_ui() const
246 {
247 return slv2_ui_is_a(_ui, _world.external_gui);
248 }
249
250 string
251 LV2Plugin::unique_id() const
252 {
253 return slv2_value_as_uri(slv2_plugin_get_uri(_plugin));
254 }
255
256 float
257 LV2Plugin::default_value(uint32_t port)
258 {
259 return _defaults[port];
260 }
261
262 const char*
263 LV2Plugin::port_symbol(uint32_t index) const
264 {
265 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, index);
266 if (!port) {
267 error << name() << ": Invalid port index " << index << endmsg;
268 }
269
270 SLV2Value sym = slv2_port_get_symbol(_plugin, port);
271 return slv2_value_as_string(sym);
272 }
273
274 void
275 LV2Plugin::set_parameter(uint32_t which, float val)
276 {
277 DEBUG_TRACE(DEBUG::LV2, string_compose(
278 "%1 set parameter %2 to %3\n", name(), which, val));
279
280 if (which < slv2_plugin_get_num_ports(_plugin)) {
281 _shadow_data[which] = val;
282 } else {
283 warning << string_compose(
284 _("Illegal parameter number used with plugin \"%1\". "
285 "This is a bug in either %2 or the LV2 plugin <%3>"),
286 name(), PROGRAM_NAME, unique_id()) << endmsg;
287 }
288
289 Plugin::set_parameter(which, val);
290 }
291
292 float
293 LV2Plugin::get_parameter(uint32_t which) const
294 {
295 if (parameter_is_input(which)) {
296 return (float)_shadow_data[which];
297 } else {
298 return (float)_control_data[which];
299 }
300 return 0.0f;
301 }
302
303 uint32_t
304 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
305 {
306 ok = false;
307 for (uint32_t c = 0, x = 0; x < slv2_plugin_get_num_ports(_plugin); ++x) {
308 if (parameter_is_control(x)) {
309 if (c++ == n) {
310 ok = true;
311 return x;
312 }
313 }
314 }
315
316 return 0;
317 }
318
319 struct PersistValue {
320 inline PersistValue(uint32_t k, const void* v, size_t s, uint32_t t, uint32_t f)
321 : key(k), value(v), size(s), type(t), flags(f)
322 {}
323
324 const uint32_t key;
325 const void* value;
326 const size_t size;
327 const uint32_t type;
328 const bool flags;
329 };
330
331 struct PersistState {
332 PersistState(URIMap& map) : uri_map(map) {}
333
334 typedef std::map<uint32_t, std::string> URIs;
335 typedef std::map<uint32_t, PersistValue> Values;
336
337 uint32_t file_id_to_runtime_id(uint32_t file_id) const {
338 URIs::const_iterator i = uris.find(file_id);
339 if (i == uris.end()) {
340 error << "LV2 state refers to undefined URI ID" << endmsg;
341 return 0;
342 }
343 return uri_map.uri_to_id(NULL, i->second.c_str());
344 }
345
346 int add_uri(uint32_t file_id, const char* str) {
347 // TODO: check for clashes (invalid file)
348 uris.insert(make_pair(file_id, str));
349 return 0;
350 }
351
352 int add_value(uint32_t file_key,
353 const void* value,
354 size_t size,
355 uint32_t file_type,
356 uint32_t flags) {
357 const uint32_t key = file_id_to_runtime_id(file_key);
358 const uint32_t type = file_id_to_runtime_id(file_type);
359 if (!key || !type) {
360 return 1;
361 }
362
363 Values::const_iterator i = values.find(key);
364 if (i != values.end()) {
365 error << "LV2 state contains duplicate keys" << endmsg;
366 return 1;
367 } else {
368 void* value_copy = malloc(size);
369 memcpy(value_copy, value, size); // FIXME: leak
370 values.insert(
371 make_pair(key,
372 PersistValue(key, value_copy, size, type, flags)));
373 return 0;
374 }
375 }
376
377 URIMap& uri_map;
378 URIs uris;
379 Values values;
380 };
381
382 int
383 LV2Plugin::lv2_persist_store_callback(void* host_data,
384 uint32_t key,
385 const void* value,
386 size_t size,
387 uint32_t type,
388 uint32_t flags)
389 {
390 DEBUG_TRACE(DEBUG::LV2, string_compose(
391 "persist store %1 (size: %2, type: %3)\n",
392 _uri_map.id_to_uri(NULL, key),
393 size,
394 _uri_map.id_to_uri(NULL, type)));
395
396 PersistState* state = (PersistState*)host_data;
397 state->add_uri(key, _uri_map.id_to_uri(NULL, key));
398 state->add_uri(type, _uri_map.id_to_uri(NULL, type));
399 return state->add_value(key, value, size, type, flags);
400 }
401
402 const void*
403 LV2Plugin::lv2_persist_retrieve_callback(void* host_data,
404 uint32_t key,
405 size_t* size,
406 uint32_t* type,
407 uint32_t* flags)
408 {
409 PersistState* state = (PersistState*)host_data;
410 PersistState::Values::const_iterator i = state->values.find(key);
411 if (i == state->values.end()) {
412 warning << "LV2 plugin attempted to retrieve nonexistent key: "
413 << _uri_map.id_to_uri(NULL, key) << endmsg;
414 return NULL;
415 }
416 *size = i->second.size;
417 *type = i->second.type;
418 *flags = LV2_PERSIST_IS_POD | LV2_PERSIST_IS_PORTABLE; // FIXME
419 DEBUG_TRACE(DEBUG::LV2, string_compose(
420 "persist retrieve %1 = %2 (size: %3, type: %4)\n",
421 _uri_map.id_to_uri(NULL, key),
422 i->second.value, *size, *type));
423 return i->second.value;
424 }
425
426 char*
427 LV2Plugin::lv2_files_abstract_path(LV2_Files_Host_Data host_data,
428 const char* absolute_path)
429 {
430 LV2Plugin* me = (LV2Plugin*)host_data;
431 assert(me->_insert_id != PBD::ID("0"));
432
433 const std::string state_dir = Glib::build_filename(me->_session.plugins_dir(),
434 me->_insert_id.to_s());
435
436 char* ret = NULL;
437 if (strncmp(absolute_path, state_dir.c_str(), state_dir.length())) {
438 ret = g_strdup(absolute_path);
439 } else {
440 const std::string path(absolute_path + state_dir.length() + 1);
441 ret = g_strndup(path.c_str(), path.length());
442 }
443
444 DEBUG_TRACE(DEBUG::LV2, string_compose("abstract path %1 => %2\n",
445 absolute_path, ret));
446
447 return ret;
448 }
449
450 char*
451 LV2Plugin::lv2_files_absolute_path(LV2_Files_Host_Data host_data,
452 const char* abstract_path)
453 {
454 LV2Plugin* me = (LV2Plugin*)host_data;
455 assert(me->_insert_id != PBD::ID("0"));
456
457 char* ret = NULL;
458 if (g_path_is_absolute(abstract_path)) {
459 ret = g_strdup(abstract_path);
460 } else {
461 const std::string apath(abstract_path);
462 const std::string state_dir = Glib::build_filename(me->_session.plugins_dir(),
463 me->_insert_id.to_s());
464 const std::string path = Glib::build_filename(state_dir,
465 apath);
466 ret = g_strndup(path.c_str(), path.length());
467 }
468
469 DEBUG_TRACE(DEBUG::LV2, string_compose("absolute path %1 => %2\n",
470 abstract_path, ret));
471
472 return ret;
473 }
474
475 char*
476 LV2Plugin::lv2_files_new_file_path(LV2_Files_Host_Data host_data,
477 const char* relative_path)
478 {
479 LV2Plugin* me = (LV2Plugin*)host_data;
480 assert(me->_insert_id != PBD::ID("0"));
481
482 const std::string state_dir = Glib::build_filename(me->_session.plugins_dir(),
483 me->_insert_id.to_s());
484 const std::string path = Glib::build_filename(state_dir,
485 relative_path);
486
487 char* dirname = g_path_get_dirname(path.c_str());
488 g_mkdir_with_parents(dirname, 0744);
489 free(dirname);
490
491 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
492 relative_path, path));
493
494 return g_strndup(path.c_str(), path.length());
495 }
496
497 void
498 LV2Plugin::add_state(XMLNode* root) const
499 {
500 assert(_insert_id != PBD::ID("0"));
501
502 XMLNode* child;
503 char buf[16];
504 LocaleGuard lg(X_("POSIX"));
505
506 for (uint32_t i = 0; i < parameter_count(); ++i) {
507 if (parameter_is_input(i) && parameter_is_control(i)) {
508 child = new XMLNode("Port");
509 child->add_property("symbol", port_symbol(i));
510 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
511 child->add_property("value", string(buf));
512 root->add_child_nocopy(*child);
513 }
514 }
515
516 if (_supports_persist) {
517 // Create state directory for this plugin instance
518 const std::string state_filename = _insert_id.to_s() + ".rdff";
519 const std::string state_path = Glib::build_filename(
520 _session.plugins_dir(), state_filename);
521
522 cout << "Saving LV2 plugin state to " << state_path << endl;
523
524 // Get LV2 Persist extension data from plugin instance
525 LV2_Persist* persist = (LV2_Persist*)slv2_instance_get_extension_data(
526 _instance, "http://lv2plug.in/ns/ext/persist");
527 if (!persist) {
528 warning << string_compose(
529 _("Plugin \"%1\% failed to return LV2 persist data"),
530 unique_id());
531 return;
532 }
533
534 // Save plugin state to state object
535 PersistState state(_uri_map);
536 persist->save(_instance->lv2_handle,
537 &LV2Plugin::lv2_persist_store_callback,
538 &state);
539
540 // Open state file
541 RDFF file = rdff_open(state_path.c_str(), true);
542
543 // Write all referenced URIs to state file
544 for (PersistState::URIs::const_iterator i = state.uris.begin();
545 i != state.uris.end(); ++i) {
546 rdff_write_uri(file,
547 i->first,
548 i->second.length(),
549 i->second.c_str());
550 }
551
552 // Write all values to state file
553 for (PersistState::Values::const_iterator i = state.values.begin();
554 i != state.values.end(); ++i) {
555 const uint32_t key = i->first;
556 const PersistValue& val = i->second;
557 rdff_write_triple(file,
558 0,
559 key,
560 val.type,
561 val.size,
562 val.value);
563 }
564
565 // Close state file
566 rdff_close(file);
567
568 root->add_property("state-file", state_filename);
569 }
570 }
571
572 static inline SLV2Value
573 get_value(SLV2Plugin p, SLV2Value subject, SLV2Value predicate)
574 {
575 SLV2Values vs = slv2_plugin_get_value_for_subject(p, subject, predicate);
576 return vs ? slv2_values_get_at(vs, 0) : NULL;
577 }
578
579 void
580 LV2Plugin::find_presets()
581 {
582 SLV2Value dc_title = slv2_value_new_uri(_world.world, NS_DC "title");
583 SLV2Value pset_hasPreset = slv2_value_new_uri(_world.world, NS_PSET "hasPreset");
584
585 SLV2Values presets = slv2_plugin_get_value(_plugin, pset_hasPreset);
586 for (unsigned i = 0; i < slv2_values_size(presets); ++i) {
587 SLV2Value preset = slv2_values_get_at(presets, i);
588 SLV2Value name = get_value(_plugin, preset, dc_title);
589 if (name) {
590 _presets.insert(std::make_pair(slv2_value_as_string(preset),
591 PresetRecord(
592 slv2_value_as_string(preset),
593 slv2_value_as_string(name))));
594 } else {
595 warning << string_compose(
596 _("Plugin \"%1\% preset \"%2%\" is missing a dc:title\n"),
597 unique_id(), slv2_value_as_string(preset));
598 }
599 }
600 slv2_values_free(presets);
601
602 slv2_value_free(pset_hasPreset);
603 slv2_value_free(dc_title);
604 }
605
606 bool
607 LV2Plugin::load_preset(PresetRecord r)
608 {
609 Plugin::load_preset(r);
610
611 #ifdef HAVE_NEW_SLV2
612 // New (>= 0.7.0) slv2 no longer supports SPARQL, but exposes blank nodes
613 // so querying ports is possible with the simple/fast API
614 SLV2Value lv2_port = slv2_value_new_uri(_world.world, NS_LV2 "port");
615 SLV2Value lv2_symbol = slv2_value_new_uri(_world.world, NS_LV2 "symbol");
616 SLV2Value pset_value = slv2_value_new_uri(_world.world, NS_PSET "value");
617 SLV2Value preset = slv2_value_new_uri(_world.world, r.uri.c_str());
618
619 SLV2Values ports = slv2_plugin_get_value_for_subject(_plugin, preset, lv2_port);
620 for (unsigned i = 0; i < slv2_values_size(ports); ++i) {
621 SLV2Value port = slv2_values_get_at(ports, i);
622 SLV2Value symbol = get_value(_plugin, port, lv2_symbol);
623 SLV2Value value = get_value(_plugin, port, pset_value);
624 if (value && slv2_value_is_float(value)) {
625 set_parameter(_port_indices[slv2_value_as_string(symbol)],
626 slv2_value_as_float(value));
627 }
628 }
629 slv2_values_free(ports);
630
631 slv2_value_free(preset);
632 slv2_value_free(pset_value);
633 slv2_value_free(lv2_symbol);
634 slv2_value_free(lv2_port);
635 #else
636 const string query = string(
637 "PREFIX lv2p: <http://lv2plug.in/ns/dev/presets#>\n"
638 "PREFIX dc: <http://dublincore.org/documents/dcmi-namespace/>\n"
639 "SELECT ?sym ?val WHERE { <") + r.uri + "> lv2:port ?port . "
640 " ?port lv2:symbol ?sym ; lv2p:value ?val . }";
641 SLV2Results values = slv2_plugin_query_sparql(_plugin, query.c_str());
642 for (; !slv2_results_finished(values); slv2_results_next(values)) {
643 SLV2Value sym = slv2_results_get_binding_value(values, 0);
644 SLV2Value val = slv2_results_get_binding_value(values, 1);
645 if (slv2_value_is_float(val)) {
646 uint32_t index = _port_indices[slv2_value_as_string(sym)];
647 set_parameter(index, slv2_value_as_float(val));
648 }
649 }
650 slv2_results_free(values);
651 #endif
652 return true;
653 }
654
655 std::string
656 LV2Plugin::do_save_preset(string /*name*/)
657 {
658 return "";
659 }
660
661 void
662 LV2Plugin::do_remove_preset(string /*name*/)
663 {}
664
665 bool
666 LV2Plugin::has_editor() const
667 {
668 return _ui != NULL;
669 }
670
671 void
672 LV2Plugin::set_insert_info(const PluginInsert* insert)
673 {
674 _insert_id = insert->id();
675 }
676
677 int
678 LV2Plugin::set_state(const XMLNode& node, int version)
679 {
680 XMLNodeList nodes;
681 const XMLProperty* prop;
682 XMLNodeConstIterator iter;
683 XMLNode* child;
684 const char* sym;
685 const char* value;
686 uint32_t port_id;
687 LocaleGuard lg(X_("POSIX"));
688
689 if (node.name() != state_node_name()) {
690 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
691 return -1;
692 }
693
694 if (version < 3000) {
695 nodes = node.children("port");
696 } else {
697 nodes = node.children("Port");
698 }
699
700 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
701
702 child = *iter;
703
704 if ((prop = child->property("symbol")) != 0) {
705 sym = prop->value().c_str();
706 } else {
707 warning << _("LV2: port has no symbol, ignored") << endmsg;
708 continue;
709 }
710
711 map<string, uint32_t>::iterator i = _port_indices.find(sym);
712
713 if (i != _port_indices.end()) {
714 port_id = i->second;
715 } else {
716 warning << _("LV2: port has unknown index, ignored") << endmsg;
717 continue;
718 }
719
720 if ((prop = child->property("value")) != 0) {
721 value = prop->value().c_str();
722 } else {
723 warning << _("LV2: port has no value, ignored") << endmsg;
724 continue;
725 }
726
727 set_parameter(port_id, atof(value));
728 }
729
730 if ((prop = node.property("state-file")) != 0) {
731 std::string state_path = Glib::build_filename(_session.plugins_dir(),
732 prop->value());
733
734 cout << "LV2 state path " << state_path << endl;
735
736 // Get LV2 Persist extension data from plugin instance
737 LV2_Persist* persist = (LV2_Persist*)slv2_instance_get_extension_data(
738 _instance, "http://lv2plug.in/ns/ext/persist");
739 if (persist) {
740 cout << "Loading LV2 state from " << state_path << endl;
741 RDFF file = rdff_open(state_path.c_str(), false);
742
743 PersistState state(_uri_map);
744
745 // Load file into state object
746 RDFFChunk* chunk = (RDFFChunk*)malloc(sizeof(RDFFChunk));
747 chunk->size = 0;
748 while (!rdff_read_chunk(file, &chunk)) {
749 if (rdff_chunk_is_uri(chunk)) {
750 RDFFURIChunk* body = (RDFFURIChunk*)chunk->data;
751 state.add_uri(body->id, body->uri);
752 } else if (rdff_chunk_is_triple(chunk)) {
753 RDFFTripleChunk* body = (RDFFTripleChunk*)chunk->data;
754 state.add_value(body->predicate,
755 body->object,
756 body->object_size,
757 body->object_type,
758 LV2_PERSIST_IS_POD | LV2_PERSIST_IS_PORTABLE);
759 }
760 }
761 free(chunk);
762
763 persist->restore(_instance->lv2_handle,
764 &LV2Plugin::lv2_persist_retrieve_callback,
765 &state);
766 rdff_close(file);
767 } else {
768 warning << string_compose(
769 _("Plugin \"%1\% failed to return LV2 persist data"),
770 unique_id());
771 }
772 }
773
774 latency_compute_run();
775
776 return Plugin::set_state(node, version);
777 }
778
779 int
780 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
781 {
782 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, which);
783
784 SLV2Value def, min, max;
785 slv2_port_get_range(_plugin, port, &def, &min, &max);
786
787 desc.integer_step = slv2_port_has_property(_plugin, port, _world.integer);
788 desc.toggled = slv2_port_has_property(_plugin, port, _world.toggled);
789 desc.logarithmic = slv2_port_has_property(_plugin, port, _world.logarithmic);
790 desc.sr_dependent = slv2_port_has_property(_plugin, port, _world.srate);
791 desc.label = slv2_value_as_string(slv2_port_get_name(_plugin, port));
792 desc.lower = min ? slv2_value_as_float(min) : 0.0f;
793 desc.upper = max ? slv2_value_as_float(max) : 1.0f;
794 desc.min_unbound = false; // TODO: LV2 extension required
795 desc.max_unbound = false; // TODO: LV2 extension required
796
797 if (desc.integer_step) {
798 desc.step = 1.0;
799 desc.smallstep = 0.1;
800 desc.largestep = 10.0;
801 } else {
802 const float delta = desc.upper - desc.lower;
803 desc.step = delta / 1000.0f;
804 desc.smallstep = delta / 10000.0f;
805 desc.largestep = delta / 10.0f;
806 }
807
808 slv2_value_free(def);
809 slv2_value_free(min);
810 slv2_value_free(max);
811
812 return 0;
813 }
814
815 string
816 LV2Plugin::describe_parameter(Evoral::Parameter which)
817 {
818 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
819 SLV2Value name = slv2_port_get_name(_plugin,
820 slv2_plugin_get_port_by_index(_plugin, which.id()));
821 string ret(slv2_value_as_string(name));
822 slv2_value_free(name);
823 return ret;
824 } else {
825 return "??";
826 }
827 }
828
829 framecnt_t
830 LV2Plugin::signal_latency() const
831 {
832 if (_latency_control_port) {
833 return (framecnt_t)floor(*_latency_control_port);
834 } else {
835 return 0;
836 }
837 }
838
839 set<Evoral::Parameter>
840 LV2Plugin::automatable() const
841 {
842 set<Evoral::Parameter> ret;
843
844 for (uint32_t i = 0; i < parameter_count(); ++i) {
845 if (parameter_is_input(i) && parameter_is_control(i)) {
846 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
847 }
848 }
849
850 return ret;
851 }
852
853 void
854 LV2Plugin::activate()
855 {
856 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
857
858 if (!_was_activated) {
859 slv2_instance_activate(_instance);
860 _was_activated = true;
861 }
862 }
863
864 void
865 LV2Plugin::deactivate()
866 {
867 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
868
869 if (_was_activated) {
870 slv2_instance_deactivate(_instance);
871 _was_activated = false;
872 }
873 }
874
875 void
876 LV2Plugin::cleanup()
877 {
878 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
879
880 activate();
881 deactivate();
882 slv2_instance_free(_instance);
883 _instance = NULL;
884 }
885
886 int
887 LV2Plugin::connect_and_run(BufferSet& bufs,
888 ChanMapping in_map, ChanMapping out_map,
889 pframes_t nframes, framecnt_t offset)
890 {
891 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
892 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
893
894 cycles_t then = get_cycles();
895
896 uint32_t audio_in_index = 0;
897 uint32_t audio_out_index = 0;
898 uint32_t midi_in_index = 0;
899 uint32_t midi_out_index = 0;
900 for (uint32_t port_index = 0; port_index < parameter_count(); ++port_index) {
901 if (parameter_is_audio(port_index)) {
902 if (parameter_is_input(port_index)) {
903 const uint32_t buf_index = in_map.get(DataType::AUDIO, audio_in_index++);
904 slv2_instance_connect_port(_instance, port_index,
905 bufs.get_audio(buf_index).data(offset));
906 } else if (parameter_is_output(port_index)) {
907 const uint32_t buf_index = out_map.get(DataType::AUDIO, audio_out_index++);
908 //cerr << port_index << " : " << " AUDIO OUT " << buf_index << endl;
909 slv2_instance_connect_port(_instance, port_index,
910 bufs.get_audio(buf_index).data(offset));
911 }
912 } else if (parameter_is_midi(port_index)) {
913 if (parameter_is_input(port_index)) {
914 const uint32_t buf_index = in_map.get(DataType::MIDI, midi_in_index++);
915 slv2_instance_connect_port(_instance, port_index,
916 bufs.get_lv2_midi(true, buf_index).data());
917 } else if (parameter_is_output(port_index)) {
918 const uint32_t buf_index = out_map.get(DataType::MIDI, midi_out_index++);
919 slv2_instance_connect_port(_instance, port_index,
920 bufs.get_lv2_midi(false, buf_index).data());
921 }
922 } else if (!parameter_is_control(port_index)) {
923 // Optional port (it'd better be if we've made it this far...)
924 slv2_instance_connect_port(_instance, port_index, NULL);
925 }
926 }
927
928 run(nframes);
929
930 midi_out_index = 0;
931 for (uint32_t port_index = 0; port_index < parameter_count(); ++port_index) {
932 if (parameter_is_midi(port_index) && parameter_is_output(port_index)) {
933 const uint32_t buf_index = out_map.get(DataType::MIDI, midi_out_index++);
934 bufs.flush_lv2_midi(true, buf_index);
935 }
936 }
937
938 cycles_t now = get_cycles();
939 set_cycles((uint32_t)(now - then));
940
941 return 0;
942 }
943
944 bool
945 LV2Plugin::parameter_is_control(uint32_t param) const
946 {
947 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
948 return slv2_port_is_a(_plugin, port, _world.control_class);
949 }
950
951 bool
952 LV2Plugin::parameter_is_audio(uint32_t param) const
953 {
954 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
955 return slv2_port_is_a(_plugin, port, _world.audio_class);
956 }
957
958 bool
959 LV2Plugin::parameter_is_midi(uint32_t param) const
960 {
961 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
962 return slv2_port_is_a(_plugin, port, _world.event_class);
963 // && slv2_port_supports_event(_plugin, port, _world.midi_class);
964 }
965
966 bool
967 LV2Plugin::parameter_is_output(uint32_t param) const
968 {
969 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
970 return slv2_port_is_a(_plugin, port, _world.output_class);
971 }
972
973 bool
974 LV2Plugin::parameter_is_input(uint32_t param) const
975 {
976 SLV2Port port = slv2_plugin_get_port_by_index(_plugin, param);
977 return slv2_port_is_a(_plugin, port, _world.input_class);
978 }
979
980 void
981 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
982 {
983 if (buf && len) {
984 if (param < parameter_count()) {
985 snprintf(buf, len, "%.3f", get_parameter(param));
986 } else {
987 strcat(buf, "0");
988 }
989 }
990 }
991
992 void
993 LV2Plugin::run(pframes_t nframes)
994 {
995 for (uint32_t i = 0; i < parameter_count(); ++i) {
996 if (parameter_is_control(i) && parameter_is_input(i)) {
997 _control_data[i] = _shadow_data[i];
998 }
999 }
1000
1001 slv2_instance_run(_instance, nframes);
1002 }
1003
1004 void
1005 LV2Plugin::latency_compute_run()
1006 {
1007 if (!_latency_control_port) {
1008 return;
1009 }
1010
1011 // Run the plugin so that it can set its latency parameter
1012
1013 activate();
1014
1015 uint32_t port_index = 0;
1016 uint32_t in_index = 0;
1017 uint32_t out_index = 0;
1018
1019 const framecnt_t bufsize = 1024;
1020 float buffer[bufsize];
1021
1022 memset(buffer, 0, sizeof(float) * bufsize);
1023
1024 // FIXME: Ensure plugins can handle in-place processing
1025
1026 port_index = 0;
1027
1028 while (port_index < parameter_count()) {
1029 if (parameter_is_audio(port_index)) {
1030 if (parameter_is_input(port_index)) {
1031 slv2_instance_connect_port(_instance, port_index, buffer);
1032 in_index++;
1033 } else if (parameter_is_output(port_index)) {
1034 slv2_instance_connect_port(_instance, port_index, buffer);
1035 out_index++;
1036 }
1037 }
1038 port_index++;
1039 }
1040
1041 run(bufsize);
1042 deactivate();
1043 }
1044
1045 LV2World::LV2World()
1046 : world(slv2_world_new())
1047 {
1048 slv2_world_load_all(world);
1049 input_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_INPUT);
1050 output_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_OUTPUT);
1051 control_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_CONTROL);
1052 audio_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_AUDIO);
1053 event_class = slv2_value_new_uri(world, SLV2_PORT_CLASS_EVENT);
1054 midi_class = slv2_value_new_uri(world, SLV2_EVENT_CLASS_MIDI);
1055 in_place_broken = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "inPlaceBroken");
1056 integer = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "integer");
1057 toggled = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "toggled");
1058 srate = slv2_value_new_uri(world, SLV2_NAMESPACE_LV2 "sampleRate");
1059 gtk_gui = slv2_value_new_uri(world, NS_UI "GtkUI");
1060 external_gui = slv2_value_new_uri(world, NS_UI "external");
1061 logarithmic = slv2_value_new_uri(world, "http://lv2plug.in/ns/dev/extportinfo#logarithmic");
1062 }
1063
1064 LV2World::~LV2World()
1065 {
1066 slv2_value_free(input_class);
1067 slv2_value_free(output_class);
1068 slv2_value_free(control_class);
1069 slv2_value_free(audio_class);
1070 slv2_value_free(event_class);
1071 slv2_value_free(midi_class);
1072 slv2_value_free(in_place_broken);
1073 }
1074
1075 LV2PluginInfo::LV2PluginInfo (void* lv2_world, void* slv2_plugin)
1076 : _lv2_world(lv2_world)
1077 , _slv2_plugin(slv2_plugin)
1078 {
1079 type = ARDOUR::LV2;
1080 }
1081
1082 LV2PluginInfo::~LV2PluginInfo()
1083 {}
1084
1085 PluginPtr
1086 LV2PluginInfo::load(Session& session)
1087 {
1088 try {
1089 PluginPtr plugin;
1090
1091 plugin.reset(new LV2Plugin(session.engine(), session,
1092 *(LV2World*)_lv2_world, (SLV2Plugin)_slv2_plugin,
1093 session.frame_rate()));
1094
1095 plugin->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
1096 return plugin;
1097 } catch (failed_constructor& err) {
1098 return PluginPtr((Plugin*)0);
1099 }
1100
1101 return PluginPtr();
1102 }
1103
1104 PluginInfoList*
1105 LV2PluginInfo::discover(void* lv2_world)
1106 {
1107 PluginInfoList* plugs = new PluginInfoList;
1108 LV2World* world = (LV2World*)lv2_world;
1109 SLV2Plugins plugins = slv2_world_get_all_plugins(world->world);
1110
1111 cerr << "LV2: Discovering " << slv2_plugins_size(plugins) << " plugins" << endl;
1112
1113 for (unsigned i = 0; i < slv2_plugins_size(plugins); ++i) {
1114 SLV2Plugin p = slv2_plugins_get_at(plugins, i);
1115 LV2PluginInfoPtr info(new LV2PluginInfo(lv2_world, p));
1116
1117 SLV2Value name = slv2_plugin_get_name(p);
1118
1119 if (!name) {
1120 cerr << "LV2: invalid plugin\n";
1121 continue;
1122 }
1123
1124 info->type = LV2;
1125
1126 info->name = string(slv2_value_as_string(name));
1127 slv2_value_free(name);
1128
1129 SLV2PluginClass pclass = slv2_plugin_get_class(p);
1130 SLV2Value label = slv2_plugin_class_get_label(pclass);
1131 info->category = slv2_value_as_string(label);
1132
1133 SLV2Value author_name = slv2_plugin_get_author_name(p);
1134 info->creator = author_name ? string(slv2_value_as_string(author_name)) : "Unknown";
1135 slv2_value_free(author_name);
1136
1137 info->path = "/NOPATH"; // Meaningless for LV2
1138
1139 info->n_inputs.set_audio(
1140 slv2_plugin_get_num_ports_of_class(
1141 p, world->input_class, world->audio_class, NULL));
1142 info->n_inputs.set_midi(
1143 slv2_plugin_get_num_ports_of_class(
1144 p, world->input_class, world->event_class, NULL));
1145
1146 info->n_outputs.set_audio(
1147 slv2_plugin_get_num_ports_of_class(
1148 p, world->output_class, world->audio_class, NULL));
1149 info->n_outputs.set_midi(
1150 slv2_plugin_get_num_ports_of_class(
1151 p, world->output_class, world->event_class, NULL));
1152
1153 info->unique_id = slv2_value_as_uri(slv2_plugin_get_uri(p));
1154 info->index = 0; // Meaningless for LV2
1155
1156 plugs->push_back(info);
1157 }
1158
1159 cerr << "Done LV2 discovery" << endl;
1160
1161 return plugs;
1162 }
Digital Audio Workstation