2 Copyright (C) 2008-2012 Paul Davis
3 Author: David Robillard
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.
28 #include <glib/gstdio.h>
29 #include <glib/gprintf.h>
32 #include <boost/utility.hpp>
34 #include "pbd/file_utils.h"
35 #include "pbd/stl_delete.h"
36 #include "pbd/compose.h"
37 #include "pbd/error.h"
38 #include "pbd/xml++.h"
40 #include "libardour-config.h"
42 #include "ardour/audio_buffer.h"
43 #include "ardour/audioengine.h"
44 #include "ardour/debug.h"
45 #include "ardour/lv2_plugin.h"
46 #include "ardour/session.h"
47 #include "ardour/tempo.h"
48 #include "ardour/types.h"
49 #include "ardour/utils.h"
50 #include "ardour/worker.h"
51 #include "ardour/search_paths.h"
56 #include <lilv/lilv.h>
58 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
59 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
60 #include "lv2/lv2plug.in/ns/ext/log/log.h"
61 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
62 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
63 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
64 #include "lv2/lv2plug.in/ns/ext/state/state.h"
65 #include "lv2/lv2plug.in/ns/ext/time/time.h"
66 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
67 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
68 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
69 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
70 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
72 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
73 #include "lv2/lv2plug.in/ns/ext/options/options.h"
76 #include "lv2_evbuf.h"
79 #include <suil/suil.h>
82 // Compatibility for old LV2
83 #ifndef LV2_ATOM_CONTENTS_CONST
84 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
85 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
87 #ifndef LV2_ATOM_BODY_CONST
88 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
90 #ifndef LV2_PATCH__property
91 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
93 #ifndef LV2_PATCH__value
94 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
96 #ifndef LV2_PATCH__writable
97 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
100 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
101 This needs to be roughly the number of cycles the UI will get around to
102 actually processing the traffic. Lower values are flakier but save memory.
104 static const size_t NBUFS = 4;
107 using namespace ARDOUR;
110 class LV2World : boost::noncopyable {
115 void load_bundled_plugins(bool verbose=false);
119 LilvNode* atom_AtomPort;
120 LilvNode* atom_Chunk;
121 LilvNode* atom_Sequence;
122 LilvNode* atom_bufferType;
123 LilvNode* atom_eventTransfer;
124 LilvNode* atom_supports;
125 LilvNode* ev_EventPort;
126 LilvNode* ext_logarithmic;
127 LilvNode* ext_notOnGUI;
128 LilvNode* lv2_AudioPort;
129 LilvNode* lv2_ControlPort;
130 LilvNode* lv2_InputPort;
131 LilvNode* lv2_OutputPort;
132 LilvNode* lv2_enumeration;
133 LilvNode* lv2_freewheeling;
134 LilvNode* lv2_inPlaceBroken;
135 LilvNode* lv2_integer;
136 LilvNode* lv2_default;
137 LilvNode* lv2_minimum;
138 LilvNode* lv2_maximum;
139 LilvNode* lv2_reportsLatency;
140 LilvNode* lv2_sampleRate;
141 LilvNode* lv2_toggled;
142 LilvNode* midi_MidiEvent;
143 LilvNode* rdfs_comment;
144 LilvNode* rdfs_label;
145 LilvNode* rdfs_range;
146 LilvNode* rsz_minimumSize;
147 LilvNode* time_Position;
149 LilvNode* ui_external;
150 LilvNode* ui_externalkx;
152 LilvNode* units_unit;
153 LilvNode* units_render;
154 LilvNode* units_midiNote;
155 LilvNode* patch_writable;
156 LilvNode* patch_Message;
159 bool _bundle_checked;
162 static LV2World _world;
164 /* worker extension */
166 /** Called by the plugin to schedule non-RT work. */
167 static LV2_Worker_Status
168 work_schedule(LV2_Worker_Schedule_Handle handle,
172 LV2Plugin* plugin = (LV2Plugin*)handle;
173 if (plugin->session().engine().freewheeling()) {
174 // Freewheeling, do the work immediately in this (audio) thread
175 return (LV2_Worker_Status)plugin->work(size, data);
177 // Enqueue message for the worker thread
178 return plugin->worker()->schedule(size, data) ?
179 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
183 /** Called by the plugin to respond to non-RT work. */
184 static LV2_Worker_Status
185 work_respond(LV2_Worker_Respond_Handle handle,
189 LV2Plugin* plugin = (LV2Plugin*)handle;
190 if (plugin->session().engine().freewheeling()) {
191 // Freewheeling, respond immediately in this (audio) thread
192 return (LV2_Worker_Status)plugin->work_response(size, data);
194 // Enqueue response for the worker
195 return plugin->worker()->respond(size, data) ?
196 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
203 log_vprintf(LV2_Log_Handle /*handle*/,
209 const int ret = g_vasprintf(&str, fmt, args);
210 if (type == URIMap::instance().urids.log_Error) {
211 error << str << endmsg;
212 } else if (type == URIMap::instance().urids.log_Warning) {
213 warning << str << endmsg;
214 } else if (type == URIMap::instance().urids.log_Note) {
215 info << str << endmsg;
217 // TODO: Toggleable log:Trace message support
222 log_printf(LV2_Log_Handle handle,
224 const char* fmt, ...)
228 const int ret = log_vprintf(handle, type, fmt, args);
233 struct LV2Plugin::Impl {
234 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
239 /** Find the LV2 input port with the given designation.
240 * If found, bufptrs[port_index] will be set to bufptr.
242 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
244 const LilvPlugin* plugin;
246 const LilvNode* ui_type;
249 LilvInstance* instance;
250 const LV2_Worker_Interface* work_iface;
252 LV2_Atom_Forge forge;
253 LV2_Atom_Forge ui_forge;
256 LV2Plugin::LV2Plugin (AudioEngine& engine,
258 const void* c_plugin,
260 : Plugin (engine, session)
266 , _patch_port_in_index((uint32_t)-1)
267 , _patch_port_out_index((uint32_t)-1)
268 , _uri_map(URIMap::instance())
270 init(c_plugin, rate);
273 LV2Plugin::LV2Plugin (const LV2Plugin& other)
279 , _insert_id(other._insert_id)
280 , _patch_port_in_index((uint32_t)-1)
281 , _patch_port_out_index((uint32_t)-1)
282 , _uri_map(URIMap::instance())
284 init(other._impl->plugin, other._sample_rate);
286 for (uint32_t i = 0; i < parameter_count(); ++i) {
287 _control_data[i] = other._shadow_data[i];
288 _shadow_data[i] = other._shadow_data[i];
293 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
295 DEBUG_TRACE(DEBUG::LV2, "init\n");
297 _impl->plugin = (const LilvPlugin*)c_plugin;
299 _impl->ui_type = NULL;
304 _atom_ev_buffers = 0;
306 _bpm_control_port = 0;
307 _freewheel_control_port = 0;
308 _latency_control_port = 0;
309 _next_cycle_start = std::numeric_limits<framepos_t>::max();
310 _next_cycle_speed = 1.0;
311 _block_length = _engine.samples_per_cycle();
312 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
314 _was_activated = false;
315 _has_state_interface = false;
317 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
318 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
319 _make_path_feature.URI = LV2_STATE__makePath;
320 _log_feature.URI = LV2_LOG__log;
321 _work_schedule_feature.URI = LV2_WORKER__schedule;
322 _work_schedule_feature.data = NULL;
323 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
324 _def_state_feature.data = NULL;
326 const LilvPlugin* plugin = _impl->plugin;
328 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
329 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
330 _has_state_interface =
331 // What plugins should have (lv2:extensionData state:Interface)
332 lilv_plugin_has_extension_data(plugin, state_iface_uri)
333 // What some outdated/incorrect ones have
334 || lilv_plugin_has_feature(plugin, state_uri);
335 lilv_node_free(state_uri);
336 lilv_node_free(state_iface_uri);
338 _features = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
339 _features[0] = &_instance_access_feature;
340 _features[1] = &_data_access_feature;
341 _features[2] = &_make_path_feature;
342 _features[3] = _uri_map.uri_map_feature();
343 _features[4] = _uri_map.urid_map_feature();
344 _features[5] = _uri_map.urid_unmap_feature();
345 _features[6] = &_log_feature;
347 unsigned n_features = 7;
348 #ifdef HAVE_LV2_1_2_0
349 _features[n_features++] = &_def_state_feature;
352 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
353 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
355 #ifdef HAVE_LV2_1_2_0
356 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
357 LV2_Options_Option options[] = {
358 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
359 sizeof(int32_t), atom_Int, &_block_length },
360 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
361 sizeof(int32_t), atom_Int, &_block_length },
362 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
363 sizeof(int32_t), atom_Int, &_seq_size },
364 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
367 _options_feature.URI = LV2_OPTIONS__options;
368 _options_feature.data = options;
369 _features[n_features++] = &_options_feature;
372 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
373 sizeof(LV2_State_Make_Path));
374 make_path->handle = this;
375 make_path->path = &lv2_state_make_path;
376 _make_path_feature.data = make_path;
378 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
380 log->printf = &log_printf;
381 log->vprintf = &log_vprintf;
382 _log_feature.data = log;
384 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
385 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
386 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
387 sizeof(LV2_Worker_Schedule));
388 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
389 _worker = new Worker(this, buf_size);
390 schedule->handle = this;
391 schedule->schedule_work = work_schedule;
392 _work_schedule_feature.data = schedule;
393 _features[n_features++] = &_work_schedule_feature;
395 lilv_node_free(worker_schedule);
397 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
398 _impl->name = lilv_plugin_get_name(plugin);
399 _impl->author = lilv_plugin_get_author_name(plugin);
401 if (_impl->instance == 0) {
402 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
403 throw failed_constructor();
406 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
407 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
408 _data_access_feature.data = &_data_access_extension_data;
410 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
411 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
412 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
413 LV2_WORKER__interface);
415 lilv_node_free(worker_iface_uri);
417 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
418 error << string_compose(
419 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
420 lilv_node_as_string(_impl->name)) << endmsg;
421 lilv_node_free(_impl->name);
422 lilv_node_free(_impl->author);
423 throw failed_constructor();
426 #ifdef HAVE_LILV_0_16_0
427 // Load default state
428 LilvState* state = lilv_state_new_from_world(
429 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
430 if (state && _has_state_interface) {
431 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
437 const uint32_t num_ports = this->num_ports();
438 for (uint32_t i = 0; i < num_ports; ++i) {
439 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
441 size_t minimumSize = 0;
443 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
444 flags |= PORT_OUTPUT;
445 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
448 error << string_compose(
449 "LV2: \"%1\" port %2 is neither input nor output",
450 lilv_node_as_string(_impl->name), i) << endmsg;
451 throw failed_constructor();
454 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
455 flags |= PORT_CONTROL;
456 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
458 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
460 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
461 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
462 LilvNodes* buffer_types = lilv_port_get_value(
463 _impl->plugin, port, _world.atom_bufferType);
464 LilvNodes* atom_supports = lilv_port_get_value(
465 _impl->plugin, port, _world.atom_supports);
467 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
468 flags |= PORT_SEQUENCE;
469 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
472 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
473 flags |= PORT_POSITION;
475 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
476 flags |= PORT_PATCHMSG;
477 if (flags & PORT_INPUT) {
478 _patch_port_in_index = i;
480 _patch_port_out_index = i;
484 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
485 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
486 if (min_size && lilv_node_is_int(min_size)) {
487 minimumSize = lilv_node_as_int(min_size);
489 lilv_nodes_free(min_size_v);
490 lilv_nodes_free(buffer_types);
491 lilv_nodes_free(atom_supports);
493 error << string_compose(
494 "LV2: \"%1\" port %2 has no known data type",
495 lilv_node_as_string(_impl->name), i) << endmsg;
496 throw failed_constructor();
499 _port_flags.push_back(flags);
500 _port_minimumSize.push_back(minimumSize);
503 _control_data = new float[num_ports];
504 _shadow_data = new float[num_ports];
505 _defaults = new float[num_ports];
506 _ev_buffers = new LV2_Evbuf*[num_ports];
507 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
509 const bool latent = lilv_plugin_has_latency(plugin);
510 const uint32_t latency_index = (latent)
511 ? lilv_plugin_get_latency_port_index(plugin)
514 // Build an array of pointers to special parameter buffers
515 void*** params = new void**[num_ports];
516 for (uint32_t i = 0; i < num_ports; ++i) {
519 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
520 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
522 for (uint32_t i = 0; i < num_ports; ++i) {
523 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
524 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
526 // Store index in map so we can look up index by symbol
527 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
529 // Get range and default value if applicable
530 if (parameter_is_control(i)) {
532 lilv_port_get_range(plugin, port, &def, NULL, NULL);
533 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
534 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
535 _defaults[i] *= _session.frame_rate ();
539 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
541 if (latent && i == latency_index) {
542 _latency_control_port = &_control_data[i];
543 *_latency_control_port = 0;
546 if (parameter_is_input(i)) {
547 _shadow_data[i] = default_value(i);
549 *params[i] = (void*)&_shadow_data[i];
559 LilvUIs* uis = lilv_plugin_get_uis(plugin);
560 if (lilv_uis_size(uis) > 0) {
562 // Look for embeddable UI
563 LILV_FOREACH(uis, u, uis) {
564 const LilvUI* this_ui = lilv_uis_get(uis, u);
565 const LilvNode* this_ui_type = NULL;
566 if (lilv_ui_is_supported(this_ui,
570 // TODO: Multiple UI support
572 _impl->ui_type = this_ui_type;
577 // Look for Gtk native UI
578 LILV_FOREACH(uis, i, uis) {
579 const LilvUI* ui = lilv_uis_get(uis, i);
580 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
582 _impl->ui_type = _world.ui_GtkUI;
588 // If Gtk UI is not available, try to find external UI
590 LILV_FOREACH(uis, i, uis) {
591 const LilvUI* ui = lilv_uis_get(uis, i);
592 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
594 _impl->ui_type = _world.ui_external;
597 if (lilv_ui_is_a(ui, _world.ui_external)) {
599 _impl->ui_type = _world.ui_external;
605 load_supported_properties(_property_descriptors);
606 allocate_atom_event_buffers();
607 latency_compute_run();
610 LV2Plugin::~LV2Plugin ()
612 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
617 lilv_instance_free(_impl->instance);
618 lilv_node_free(_impl->name);
619 lilv_node_free(_impl->author);
622 free(_make_path_feature.data);
623 free(_work_schedule_feature.data);
629 if (_atom_ev_buffers) {
630 LV2_Evbuf** b = _atom_ev_buffers;
635 free(_atom_ev_buffers);
638 delete [] _control_data;
639 delete [] _shadow_data;
640 delete [] _ev_buffers;
644 LV2Plugin::is_external_ui() const
649 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
653 LV2Plugin::is_external_kx() const
658 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
662 LV2Plugin::ui_is_resizable () const
664 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
665 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
666 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
667 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
669 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
670 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
672 lilv_nodes_free(nrs_matches);
673 lilv_nodes_free(fs_matches);
678 return !fs_matches && !nrs_matches;
682 LV2Plugin::unique_id() const
684 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
688 LV2Plugin::uri() const
690 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
694 LV2Plugin::label() const
696 return lilv_node_as_string(_impl->name);
700 LV2Plugin::name() const
702 return lilv_node_as_string(_impl->name);
706 LV2Plugin::maker() const
708 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
712 LV2Plugin::num_ports() const
714 return lilv_plugin_get_num_ports(_impl->plugin);
718 LV2Plugin::parameter_count() const
720 return lilv_plugin_get_num_ports(_impl->plugin);
724 LV2Plugin::default_value(uint32_t port)
726 return _defaults[port];
730 LV2Plugin::port_symbol(uint32_t index) const
732 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
734 error << name() << ": Invalid port index " << index << endmsg;
737 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
738 return lilv_node_as_string(sym);
742 LV2Plugin::port_index (const char* symbol) const
744 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
745 if (i != _port_indices.end()) {
748 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
754 LV2Plugin::set_parameter(uint32_t which, float val)
756 DEBUG_TRACE(DEBUG::LV2, string_compose(
757 "%1 set parameter %2 to %3\n", name(), which, val));
759 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
760 if (get_parameter (which) == val) {
764 _shadow_data[which] = val;
766 warning << string_compose(
767 _("Illegal parameter number used with plugin \"%1\". "
768 "This is a bug in either %2 or the LV2 plugin <%3>"),
769 name(), PROGRAM_NAME, unique_id()) << endmsg;
772 Plugin::set_parameter(which, val);
776 LV2Plugin::get_parameter(uint32_t which) const
778 if (parameter_is_input(which)) {
779 return (float)_shadow_data[which];
781 return (float)_control_data[which];
787 LV2Plugin::get_docs() const
789 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
791 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
792 lilv_nodes_free(comments);
800 LV2Plugin::get_parameter_docs(uint32_t which) const
802 LilvNodes* comments = lilv_port_get_value(
804 lilv_plugin_get_port_by_index(_impl->plugin, which),
805 _world.rdfs_comment);
808 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
809 lilv_nodes_free(comments);
817 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
820 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
821 if (parameter_is_control(x)) {
833 LV2Plugin::extension_data(const char* uri) const
835 return lilv_instance_get_extension_data(_impl->instance, uri);
839 LV2Plugin::c_plugin()
841 return _impl->plugin;
847 return (const void*)_impl->ui;
851 LV2Plugin::c_ui_type()
853 return (const void*)_impl->ui_type;
856 /** Directory for all plugin state. */
858 LV2Plugin::plugin_dir() const
860 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
863 /** Directory for files created by the plugin (except during save). */
865 LV2Plugin::scratch_dir() const
867 return Glib::build_filename(plugin_dir(), "scratch");
870 /** Directory for snapshots of files in the scratch directory. */
872 LV2Plugin::file_dir() const
874 return Glib::build_filename(plugin_dir(), "files");
877 /** Directory to save state snapshot version @c num into. */
879 LV2Plugin::state_dir(unsigned num) const
881 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
884 /** Implementation of state:makePath for files created at instantiation time.
885 * Note this is not used for files created at save time (Lilv deals with that).
888 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
891 LV2Plugin* me = (LV2Plugin*)handle;
892 if (me->_insert_id == PBD::ID("0")) {
893 warning << string_compose(
894 "File path \"%1\" requested but LV2 %2 has no insert ID",
895 path, me->name()) << endmsg;
896 return g_strdup(path);
899 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
900 const std::string dirname = Glib::path_get_dirname(abs_path);
901 g_mkdir_with_parents(dirname.c_str(), 0744);
903 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
906 return g_strndup(abs_path.c_str(), abs_path.length());
910 LV2Plugin::add_state(XMLNode* root) const
912 assert(_insert_id != PBD::ID("0"));
916 LocaleGuard lg(X_("POSIX"));
918 for (uint32_t i = 0; i < parameter_count(); ++i) {
919 if (parameter_is_input(i) && parameter_is_control(i)) {
920 child = new XMLNode("Port");
921 child->add_property("symbol", port_symbol(i));
922 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
923 child->add_property("value", string(buf));
924 root->add_child_nocopy(*child);
928 if (_has_state_interface) {
929 // Provisionally increment state version and create directory
930 const std::string new_dir = state_dir(++_state_version);
931 g_mkdir_with_parents(new_dir.c_str(), 0744);
933 LilvState* state = lilv_state_new_from_instance(
937 scratch_dir().c_str(),
939 _session.externals_dir().c_str(),
942 const_cast<LV2Plugin*>(this),
946 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
947 lilv_state_save(_world.world,
949 _uri_map.urid_unmap(),
955 lilv_state_free(_impl->state);
956 _impl->state = state;
958 // State is identical, decrement version and nuke directory
959 lilv_state_free(state);
960 PBD::remove_directory(new_dir);
964 root->add_property("state-dir", string_compose("state%1", _state_version));
968 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
970 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
972 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
974 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
982 LV2Plugin::find_presets()
984 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
985 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
986 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
988 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
989 LILV_FOREACH(nodes, i, presets) {
990 const LilvNode* preset = lilv_nodes_get(presets, i);
991 lilv_world_load_resource(_world.world, preset);
992 LilvNode* name = get_value(_world.world, preset, rdfs_label);
994 _presets.insert(std::make_pair(lilv_node_as_string(preset),
995 Plugin::PresetRecord(
996 lilv_node_as_string(preset),
997 lilv_node_as_string(name))));
998 lilv_node_free(name);
1000 warning << string_compose(
1001 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1002 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1003 lilv_node_as_string(preset)) << endmsg;
1006 lilv_nodes_free(presets);
1008 lilv_node_free(rdfs_label);
1009 lilv_node_free(pset_Preset);
1010 lilv_node_free(lv2_appliesTo);
1014 set_port_value(const char* port_symbol,
1020 LV2Plugin* self = (LV2Plugin*)user_data;
1021 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1022 return; // TODO: Support non-float ports
1025 const uint32_t port_index = self->port_index(port_symbol);
1026 if (port_index != (uint32_t)-1) {
1027 self->set_parameter(port_index, *(const float*)value);
1032 LV2Plugin::load_preset(PresetRecord r)
1034 LilvWorld* world = _world.world;
1035 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1036 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1039 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1040 lilv_state_free(state);
1041 Plugin::load_preset(r);
1044 lilv_node_free(pset);
1049 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1054 LV2Plugin *plugin = (LV2Plugin *) user_data;
1056 uint32_t index = plugin->port_index(port_symbol);
1057 if (index != (uint32_t) -1) {
1058 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1060 *size = sizeof(float);
1061 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1062 value = &plugin->_shadow_data[index];
1074 LV2Plugin::do_save_preset(string name)
1076 const string base_name = legalize_for_uri(name);
1077 const string file_name = base_name + ".ttl";
1078 const string bundle = Glib::build_filename(
1079 Glib::get_home_dir(),
1080 Glib::build_filename(".lv2", base_name + ".lv2"));
1082 LilvState* state = lilv_state_new_from_instance(
1085 _uri_map.urid_map(),
1086 scratch_dir().c_str(), // file_dir
1087 bundle.c_str(), // copy_dir
1088 bundle.c_str(), // link_dir
1089 bundle.c_str(), // save_dir
1090 lv2plugin_get_port_value, // get_value
1091 (void*)this, // user_data
1092 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1093 _features // features
1096 lilv_state_set_label(state, name.c_str());
1098 _world.world, // world
1099 _uri_map.urid_map(), // map
1100 _uri_map.urid_unmap(), // unmap
1102 NULL, // uri (NULL = use file URI)
1103 bundle.c_str(), // dir
1104 file_name.c_str() // filename
1107 lilv_state_free(state);
1109 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1110 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1111 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1112 #ifdef HAVE_LILV_0_19_2
1113 lilv_world_unload_resource(_world.world, node_preset);
1114 lilv_world_unload_bundle(_world.world, node_bundle);
1116 lilv_world_load_bundle(_world.world, node_bundle);
1117 lilv_world_load_resource(_world.world, node_preset);
1118 lilv_node_free(node_bundle);
1119 lilv_node_free(node_preset);
1124 LV2Plugin::do_remove_preset(string name)
1126 string preset_file = Glib::build_filename(
1127 Glib::get_home_dir(),
1128 Glib::build_filename(
1129 Glib::build_filename(".lv2", "presets"),
1133 ::g_unlink(preset_file.c_str());
1137 LV2Plugin::has_editor() const
1139 return _impl->ui != NULL;
1143 LV2Plugin::has_message_output() const
1145 for (uint32_t i = 0; i < num_ports(); ++i) {
1146 if ((_port_flags[i] & PORT_SEQUENCE) &&
1147 (_port_flags[i] & PORT_OUTPUT)) {
1155 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1159 const uint8_t* body)
1161 const uint32_t buf_size = sizeof(UIMessage) + size;
1162 vector<uint8_t> buf(buf_size);
1164 UIMessage* msg = (UIMessage*)&buf[0];
1166 msg->protocol = protocol;
1168 memcpy(msg + 1, body, size);
1170 return (dest->write(&buf[0], buf_size) == buf_size);
1174 LV2Plugin::write_from_ui(uint32_t index,
1177 const uint8_t* body)
1180 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1181 /* buffer data communication from plugin UI to plugin instance.
1182 * this buffer needs to potentially hold
1183 * (port's minimumSize) * (audio-periods) / (UI-periods)
1186 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1187 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1188 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1190 * it is NOT safe to overflow (msg.size will be misinterpreted)
1192 uint32_t bufsiz = 32768;
1193 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1194 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1196 rbs = max((size_t) bufsiz * 8, rbs);
1197 _from_ui = new RingBuffer<uint8_t>(rbs);
1200 if (!write_to(_from_ui, index, protocol, size, body)) {
1201 error << "Error writing from UI to plugin" << endmsg;
1208 LV2Plugin::write_to_ui(uint32_t index,
1211 const uint8_t* body)
1213 if (!write_to(_to_ui, index, protocol, size, body)) {
1214 error << "Error writing from plugin to UI" << endmsg;
1221 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1223 switch (value.type()) {
1227 lv2_atom_forge_bool(forge, value.get_bool());
1229 case Variant::DOUBLE:
1230 lv2_atom_forge_double(forge, value.get_double());
1232 case Variant::FLOAT:
1233 lv2_atom_forge_float(forge, value.get_float());
1236 lv2_atom_forge_int(forge, value.get_int());
1239 lv2_atom_forge_long(forge, value.get_long());
1242 lv2_atom_forge_path(
1243 forge, value.get_path().c_str(), value.get_path().size());
1245 case Variant::STRING:
1246 lv2_atom_forge_string(
1247 forge, value.get_string().c_str(), value.get_string().size());
1251 forge, value.get_uri().c_str(), value.get_uri().size());
1256 /** Get a variant type from a URI, return false iff no match found. */
1258 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1260 if (uri == LV2_ATOM__Bool) {
1261 type = Variant::BOOL;
1262 } else if (uri == LV2_ATOM__Double) {
1263 type = Variant::DOUBLE;
1264 } else if (uri == LV2_ATOM__Float) {
1265 type = Variant::FLOAT;
1266 } else if (uri == LV2_ATOM__Int) {
1267 type = Variant::INT;
1268 } else if (uri == LV2_ATOM__Long) {
1269 type = Variant::LONG;
1270 } else if (uri == LV2_ATOM__Path) {
1271 type = Variant::PATH;
1272 } else if (uri == LV2_ATOM__String) {
1273 type = Variant::STRING;
1274 } else if (uri == LV2_ATOM__URI) {
1275 type = Variant::URI;
1283 LV2Plugin::set_property(uint32_t key, const Variant& value)
1285 if (_patch_port_in_index == (uint32_t)-1) {
1286 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1288 } else if (value.type() == Variant::VOID) {
1289 error << "LV2: set_property called with void value" << endmsg;
1293 // Set up forge to write to temporary buffer on the stack
1294 LV2_Atom_Forge* forge = &_impl->ui_forge;
1295 LV2_Atom_Forge_Frame frame;
1296 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1298 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1300 // Serialize patch:Set message to set property
1301 #ifdef HAVE_LV2_1_10_0
1302 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1303 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1304 lv2_atom_forge_urid(forge, key);
1305 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1307 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1308 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1309 lv2_atom_forge_urid(forge, key);
1310 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1313 forge_variant(forge, value);
1315 // Write message to UI=>Plugin ring
1316 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1317 write_from_ui(_patch_port_in_index,
1318 _uri_map.urids.atom_eventTransfer,
1319 lv2_atom_total_size(atom),
1320 (const uint8_t*)atom);
1323 const ParameterDescriptor&
1324 LV2Plugin::get_property_descriptor(uint32_t id) const
1326 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1327 if (p != _property_descriptors.end()) {
1330 return Plugin::get_property_descriptor(id);
1334 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1336 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1337 desc.unit = ParameterDescriptor::MIDI_NOTE;
1338 } else if (lilv_nodes_contains(units, _world.units_db)) {
1339 desc.unit = ParameterDescriptor::DB;
1340 } else if (lilv_nodes_size(units) > 0) {
1341 const LilvNode* unit = lilv_nodes_get_first(units);
1342 LilvNode* render = get_value(lworld, unit, _world.units_render);
1344 desc.print_fmt = lilv_node_as_string(render);
1345 lilv_node_free(render);
1351 load_parameter_descriptor(LV2World& world,
1352 ParameterDescriptor& desc,
1353 Variant::Type datatype,
1354 const LilvNode* subject)
1356 LilvWorld* lworld = _world.world;
1357 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1358 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1359 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1360 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1361 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1363 desc.label = lilv_node_as_string(label);
1365 if (def && lilv_node_is_float(def)) {
1366 desc.normal = lilv_node_as_float(def);
1368 if (minimum && lilv_node_is_float(minimum)) {
1369 desc.lower = lilv_node_as_float(minimum);
1371 if (maximum && lilv_node_is_float(maximum)) {
1372 desc.upper = lilv_node_as_float(maximum);
1374 load_parameter_descriptor_units(lworld, desc, units);
1375 desc.datatype = datatype;
1376 desc.toggled |= datatype == Variant::BOOL;
1377 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1378 desc.update_steps();
1380 lilv_nodes_free(units);
1381 lilv_node_free(label);
1382 lilv_node_free(def);
1383 lilv_node_free(minimum);
1384 lilv_node_free(maximum);
1388 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1390 LilvWorld* lworld = _world.world;
1391 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1392 LilvNodes* properties = lilv_world_find_nodes(
1393 lworld, subject, _world.patch_writable, NULL);
1394 LILV_FOREACH(nodes, p, properties) {
1395 // Get label and range
1396 const LilvNode* prop = lilv_nodes_get(properties, p);
1397 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1399 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1400 lilv_node_as_uri(prop)) << endmsg;
1404 // Convert range to variant type (TODO: support for multiple range types)
1405 Variant::Type datatype;
1406 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1407 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1408 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1412 // Add description to result
1413 ParameterDescriptor desc;
1414 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1415 desc.datatype = datatype;
1416 load_parameter_descriptor(_world, desc, datatype, prop);
1417 descs.insert(std::make_pair(desc.key, desc));
1419 lilv_node_free(range);
1421 lilv_nodes_free(properties);
1425 LV2Plugin::announce_property_values()
1427 if (_patch_port_in_index == (uint32_t)-1) {
1431 // Set up forge to write to temporary buffer on the stack
1432 LV2_Atom_Forge* forge = &_impl->ui_forge;
1433 LV2_Atom_Forge_Frame frame;
1434 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1436 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1438 // Serialize patch:Get message with no subject (implicitly plugin instance)
1439 #ifdef HAVE_LV2_1_10_0
1440 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1442 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1445 // Write message to UI=>Plugin ring
1446 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1447 write_from_ui(_patch_port_in_index,
1448 _uri_map.urids.atom_eventTransfer,
1449 lv2_atom_total_size(atom),
1450 (const uint8_t*)atom);
1454 LV2Plugin::enable_ui_emission()
1457 /* see note in LV2Plugin::write_from_ui() */
1458 uint32_t bufsiz = 32768;
1459 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1460 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1462 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1463 rbs = max((size_t) bufsiz * 8, rbs);
1464 _to_ui = new RingBuffer<uint8_t>(rbs);
1469 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1475 uint32_t read_space = _to_ui->read_space();
1476 while (read_space > sizeof(UIMessage)) {
1478 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1479 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1482 vector<uint8_t> body(msg.size);
1483 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1484 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1488 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1490 read_space -= sizeof(msg) + msg.size;
1495 LV2Plugin::work(uint32_t size, const void* data)
1497 return _impl->work_iface->work(
1498 _impl->instance->lv2_handle, work_respond, this, size, data);
1502 LV2Plugin::work_response(uint32_t size, const void* data)
1504 return _impl->work_iface->work_response(
1505 _impl->instance->lv2_handle, size, data);
1509 LV2Plugin::set_insert_info(const PluginInsert* insert)
1511 _insert_id = insert->id();
1515 LV2Plugin::set_state(const XMLNode& node, int version)
1518 const XMLProperty* prop;
1519 XMLNodeConstIterator iter;
1524 LocaleGuard lg(X_("POSIX"));
1526 if (node.name() != state_node_name()) {
1527 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1531 #ifndef NO_PLUGIN_STATE
1533 if (version < 3000) {
1534 nodes = node.children("port");
1536 nodes = node.children("Port");
1539 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1543 if ((prop = child->property("symbol")) != 0) {
1544 sym = prop->value().c_str();
1546 warning << _("LV2: port has no symbol, ignored") << endmsg;
1550 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1552 if (i != _port_indices.end()) {
1553 port_id = i->second;
1555 warning << _("LV2: port has unknown index, ignored") << endmsg;
1559 if ((prop = child->property("value")) != 0) {
1560 value = prop->value().c_str();
1562 warning << _("LV2: port has no value, ignored") << endmsg;
1566 set_parameter(port_id, atof(value));
1570 if ((prop = node.property("state-dir")) != 0) {
1571 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1572 error << string_compose(
1573 "LV2: failed to parse state version from \"%1\"",
1574 prop->value()) << endmsg;
1577 std::string state_file = Glib::build_filename(
1579 Glib::build_filename(prop->value(), "state.ttl"));
1581 LilvState* state = lilv_state_new_from_file(
1582 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1584 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1587 latency_compute_run();
1590 return Plugin::set_state(node, version);
1594 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1596 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1598 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1603 LilvNodes* portunits;
1604 LilvNode *def, *min, *max;
1605 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1606 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1608 // TODO: Once we can rely on lilv 0.18.0 being present,
1609 // load_parameter_descriptor() can be used for ports as well
1610 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1611 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1612 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1613 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1614 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1615 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1616 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1617 load_parameter_descriptor_units(_world.world, desc, portunits);
1619 if (desc.sr_dependent) {
1620 desc.lower *= _session.frame_rate ();
1621 desc.upper *= _session.frame_rate ();
1624 desc.min_unbound = false; // TODO: LV2 extension required
1625 desc.max_unbound = false; // TODO: LV2 extension required
1627 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1628 desc.scale_points = get_scale_points(which);
1630 desc.update_steps();
1632 lilv_node_free(def);
1633 lilv_node_free(min);
1634 lilv_node_free(max);
1635 lilv_nodes_free(portunits);
1641 LV2Plugin::describe_parameter(Evoral::Parameter which)
1643 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1645 if (lilv_port_has_property(_impl->plugin,
1646 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1647 return X_("hidden");
1650 if (lilv_port_has_property(_impl->plugin,
1651 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1652 return X_("hidden");
1655 if (lilv_port_has_property(_impl->plugin,
1656 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1657 return X_("latency");
1660 LilvNode* name = lilv_port_get_name(_impl->plugin,
1661 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1662 string ret(lilv_node_as_string(name));
1663 lilv_node_free(name);
1671 LV2Plugin::signal_latency() const
1673 if (_latency_control_port) {
1674 return (framecnt_t)floor(*_latency_control_port);
1680 set<Evoral::Parameter>
1681 LV2Plugin::automatable() const
1683 set<Evoral::Parameter> ret;
1685 for (uint32_t i = 0; i < parameter_count(); ++i) {
1686 if (parameter_is_input(i) && parameter_is_control(i)) {
1687 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1691 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1692 p != _property_descriptors.end();
1694 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1700 LV2Plugin::activate()
1702 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1704 if (!_was_activated) {
1705 lilv_instance_activate(_impl->instance);
1706 _was_activated = true;
1711 LV2Plugin::deactivate()
1713 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1715 if (_was_activated) {
1716 lilv_instance_deactivate(_impl->instance);
1717 _was_activated = false;
1722 LV2Plugin::cleanup()
1724 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1728 lilv_instance_free(_impl->instance);
1729 _impl->instance = NULL;
1733 LV2Plugin::allocate_atom_event_buffers()
1735 /* reserve local scratch buffers for ATOM event-queues */
1736 const LilvPlugin* p = _impl->plugin;
1738 /* count non-MIDI atom event-ports
1739 * TODO: nicely ask drobilla to make a lilv_ call for that
1741 int count_atom_out = 0;
1742 int count_atom_in = 0;
1743 int minimumSize = 32768; // TODO use a per-port minimum-size
1744 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1745 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1746 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1747 LilvNodes* buffer_types = lilv_port_get_value(
1748 p, port, _world.atom_bufferType);
1749 LilvNodes* atom_supports = lilv_port_get_value(
1750 p, port, _world.atom_supports);
1752 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1753 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1754 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1757 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1760 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1761 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1762 if (min_size && lilv_node_is_int(min_size)) {
1763 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1765 lilv_nodes_free(min_size_v);
1767 lilv_nodes_free(buffer_types);
1768 lilv_nodes_free(atom_supports);
1772 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1773 name(), count_atom_in, count_atom_out));
1775 const int total_atom_buffers = (count_atom_in + count_atom_out);
1776 if (_atom_ev_buffers || total_atom_buffers == 0) {
1780 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1781 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1782 for (int i = 0; i < total_atom_buffers; ++i ) {
1783 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1784 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1786 _atom_ev_buffers[total_atom_buffers] = 0;
1790 /** Write an ardour position/time/tempo/meter as an LV2 event.
1791 * @return true on success.
1794 write_position(LV2_Atom_Forge* forge,
1796 const TempoMetric& t,
1797 Timecode::BBT_Time& bbt,
1799 framepos_t position,
1802 const URIMap::URIDs& urids = URIMap::instance().urids;
1804 uint8_t pos_buf[256];
1805 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1806 LV2_Atom_Forge_Frame frame;
1807 #ifdef HAVE_LV2_1_10_0
1808 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1809 lv2_atom_forge_key(forge, urids.time_frame);
1810 lv2_atom_forge_long(forge, position);
1811 lv2_atom_forge_key(forge, urids.time_speed);
1812 lv2_atom_forge_float(forge, speed);
1813 lv2_atom_forge_key(forge, urids.time_barBeat);
1814 lv2_atom_forge_float(forge, bbt.beats - 1 +
1815 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1816 lv2_atom_forge_key(forge, urids.time_bar);
1817 lv2_atom_forge_long(forge, bbt.bars - 1);
1818 lv2_atom_forge_key(forge, urids.time_beatUnit);
1819 lv2_atom_forge_int(forge, t.meter().note_divisor());
1820 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1821 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1822 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1823 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1825 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1826 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1827 lv2_atom_forge_long(forge, position);
1828 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1829 lv2_atom_forge_float(forge, speed);
1830 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1831 lv2_atom_forge_float(forge, bbt.beats - 1 +
1832 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1833 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1834 lv2_atom_forge_long(forge, bbt.bars - 1);
1835 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1836 lv2_atom_forge_int(forge, t.meter().note_divisor());
1837 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1838 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1839 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1840 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1843 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
1844 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1845 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1846 (const uint8_t*)(atom + 1));
1850 LV2Plugin::connect_and_run(BufferSet& bufs,
1851 ChanMapping in_map, ChanMapping out_map,
1852 pframes_t nframes, framecnt_t offset)
1854 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1855 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1857 cycles_t then = get_cycles();
1859 TempoMap& tmap = _session.tempo_map();
1860 Metrics::const_iterator metric_i = tmap.metrics_end();
1861 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
1863 if (_freewheel_control_port) {
1864 *_freewheel_control_port = _session.engine().freewheeling();
1867 if (_bpm_control_port) {
1868 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1871 ChanCount bufs_count;
1872 bufs_count.set(DataType::AUDIO, 1);
1873 bufs_count.set(DataType::MIDI, 1);
1874 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
1875 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1876 uint32_t const num_ports = parameter_count();
1877 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1879 uint32_t audio_in_index = 0;
1880 uint32_t audio_out_index = 0;
1881 uint32_t midi_in_index = 0;
1882 uint32_t midi_out_index = 0;
1883 uint32_t atom_port_index = 0;
1884 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1886 uint32_t index = nil_index;
1887 PortFlags flags = _port_flags[port_index];
1889 if (flags & PORT_AUDIO) {
1890 if (flags & PORT_INPUT) {
1891 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1893 ? bufs.get_audio(index).data(offset)
1894 : silent_bufs.get_audio(0).data(offset);
1896 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1898 ? bufs.get_audio(index).data(offset)
1899 : scratch_bufs.get_audio(0).data(offset);
1901 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1902 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1903 be necessary, but the mapping is illegal in some cases. Ideally
1904 that should be fixed, but this is easier...
1906 if (flags & PORT_MIDI) {
1907 if (flags & PORT_INPUT) {
1908 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1910 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1912 if (valid && bufs.count().n_midi() > index) {
1913 /* Note, ensure_lv2_bufsize() is not RT safe!
1914 * However free()/alloc() is only called if a
1915 * plugin requires a rsz:minimumSize buffersize
1916 * and the existing buffer if smaller.
1918 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1919 _ev_buffers[port_index] = bufs.get_lv2_midi(
1920 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1922 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1923 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1924 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1928 if (valid && (flags & PORT_INPUT)) {
1929 Timecode::BBT_Time bbt;
1930 if ((flags & PORT_POSITION)) {
1931 if (_session.transport_frame() != _next_cycle_start ||
1932 _session.transport_speed() != _next_cycle_speed) {
1933 // Transport has changed, write position at cycle start
1934 tmap.bbt_time(_session.transport_frame(), bbt);
1935 write_position(&_impl->forge, _ev_buffers[port_index],
1936 tmetric, bbt, _session.transport_speed(),
1937 _session.transport_frame(), 0);
1941 // Get MIDI iterator range (empty range if no MIDI)
1942 MidiBuffer::iterator m = (index != nil_index)
1943 ? bufs.get_midi(index).begin()
1944 : silent_bufs.get_midi(0).end();
1945 MidiBuffer::iterator m_end = (index != nil_index)
1946 ? bufs.get_midi(index).end()
1949 // Now merge MIDI and any transport events into the buffer
1950 const uint32_t type = _uri_map.urids.midi_MidiEvent;
1951 const framepos_t tend = _session.transport_frame() + nframes;
1953 while (m != m_end || (metric_i != tmap.metrics_end() &&
1954 (*metric_i)->frame() < tend)) {
1955 MetricSection* metric = (metric_i != tmap.metrics_end())
1957 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1958 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1959 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1960 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1963 tmetric.set_metric(metric);
1964 bbt = metric->start();
1965 write_position(&_impl->forge, _ev_buffers[port_index],
1966 tmetric, bbt, _session.transport_speed(),
1968 metric->frame() - _session.transport_frame());
1972 } else if (!valid) {
1973 // Nothing we understand or care about, connect to scratch
1974 // see note for midi-buffer size above
1975 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
1976 0, _port_minimumSize[port_index]);
1977 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
1978 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
1981 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
1983 continue; // Control port, leave buffer alone
1985 lilv_instance_connect_port(_impl->instance, port_index, buf);
1988 // Read messages from UI and push into appropriate buffers
1990 uint32_t read_space = _from_ui->read_space();
1991 while (read_space > sizeof(UIMessage)) {
1993 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1994 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1997 vector<uint8_t> body(msg.size);
1998 if (_from_ui->read(&body[0], msg.size) != msg.size) {
1999 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2002 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2003 LV2_Evbuf* buf = _ev_buffers[msg.index];
2004 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2005 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2006 if (!lv2_evbuf_write(&i, nframes, 0, atom->type, atom->size,
2007 (const uint8_t*)(atom + 1))) {
2008 error << "Failed to write data to LV2 event buffer\n";
2011 error << "Received unknown message type from UI" << endmsg;
2013 read_space -= sizeof(UIMessage) + msg.size;
2020 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2021 PortFlags flags = _port_flags[port_index];
2024 /* TODO ask drobilla about comment
2025 * "Make Ardour event buffers generic so plugins can communicate"
2026 * in libs/ardour/buffer_set.cc:310
2028 * ideally the user could choose which of the following two modes
2029 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2031 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2032 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2033 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2034 * for quite a while at least ;)
2036 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2037 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2038 const uint32_t buf_index = out_map.get(
2039 DataType::MIDI, midi_out_index++, &valid);
2041 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2044 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2045 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2046 const uint32_t buf_index = out_map.get(
2047 DataType::MIDI, midi_out_index++, &valid);
2049 bufs.flush_lv2_midi(true, buf_index);
2054 // Write messages to UI
2055 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2056 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2057 LV2_Evbuf* buf = _ev_buffers[port_index];
2058 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2059 lv2_evbuf_is_valid(i);
2060 i = lv2_evbuf_next(i)) {
2061 uint32_t frames, subframes, type, size;
2063 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2065 // Intercept patch change messages to emit PropertyChanged signal
2066 if ((flags & PORT_PATCHMSG)) {
2067 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2068 if (atom->type == _uri_map.urids.atom_Blank ||
2069 atom->type == _uri_map.urids.atom_Object) {
2070 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2071 if (obj->body.otype == _uri_map.urids.patch_Set) {
2072 const LV2_Atom* property = NULL;
2073 const LV2_Atom* value = NULL;
2074 lv2_atom_object_get(obj,
2075 _uri_map.urids.patch_property, &property,
2076 _uri_map.urids.patch_value, &value,
2079 if (!property || !value ||
2080 property->type != _uri_map.urids.atom_URID ||
2081 value->type != _uri_map.urids.atom_Path) {
2082 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2086 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2087 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2089 // Emit PropertyChanged signal for UI
2090 // TODO: This should emit the control's Changed signal
2091 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2096 if (!_to_ui) continue;
2097 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2098 size + sizeof(LV2_Atom),
2099 data - sizeof(LV2_Atom));
2104 cycles_t now = get_cycles();
2105 set_cycles((uint32_t)(now - then));
2107 // Update expected transport information for next cycle so we can detect changes
2108 _next_cycle_speed = _session.transport_speed();
2109 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2115 LV2Plugin::parameter_is_control(uint32_t param) const
2117 assert(param < _port_flags.size());
2118 return _port_flags[param] & PORT_CONTROL;
2122 LV2Plugin::parameter_is_audio(uint32_t param) const
2124 assert(param < _port_flags.size());
2125 return _port_flags[param] & PORT_AUDIO;
2129 LV2Plugin::parameter_is_event(uint32_t param) const
2131 assert(param < _port_flags.size());
2132 return _port_flags[param] & PORT_EVENT;
2136 LV2Plugin::parameter_is_output(uint32_t param) const
2138 assert(param < _port_flags.size());
2139 return _port_flags[param] & PORT_OUTPUT;
2143 LV2Plugin::parameter_is_input(uint32_t param) const
2145 assert(param < _port_flags.size());
2146 return _port_flags[param] & PORT_INPUT;
2150 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2153 if (param < parameter_count()) {
2154 snprintf(buf, len, "%.3f", get_parameter(param));
2161 boost::shared_ptr<ScalePoints>
2162 LV2Plugin::get_scale_points(uint32_t port_index) const
2164 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2165 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2167 boost::shared_ptr<ScalePoints> ret;
2172 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2174 LILV_FOREACH(scale_points, i, points) {
2175 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2176 const LilvNode* label = lilv_scale_point_get_label(p);
2177 const LilvNode* value = lilv_scale_point_get_value(p);
2178 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2179 ret->insert(make_pair(lilv_node_as_string(label),
2180 lilv_node_as_float(value)));
2184 lilv_scale_points_free(points);
2189 LV2Plugin::run(pframes_t nframes)
2191 uint32_t const N = parameter_count();
2192 for (uint32_t i = 0; i < N; ++i) {
2193 if (parameter_is_control(i) && parameter_is_input(i)) {
2194 _control_data[i] = _shadow_data[i];
2198 lilv_instance_run(_impl->instance, nframes);
2200 if (_impl->work_iface) {
2201 _worker->emit_responses();
2202 if (_impl->work_iface->end_run) {
2203 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2209 LV2Plugin::latency_compute_run()
2211 if (!_latency_control_port) {
2215 // Run the plugin so that it can set its latency parameter
2217 bool was_activated = _was_activated;
2220 uint32_t port_index = 0;
2221 uint32_t in_index = 0;
2222 uint32_t out_index = 0;
2224 // this is done in the main thread. non realtime.
2225 const framecnt_t bufsize = _engine.samples_per_cycle();
2226 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2228 memset(buffer, 0, sizeof(float) * bufsize);
2230 // FIXME: Ensure plugins can handle in-place processing
2234 while (port_index < parameter_count()) {
2235 if (parameter_is_audio(port_index)) {
2236 if (parameter_is_input(port_index)) {
2237 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2239 } else if (parameter_is_output(port_index)) {
2240 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2249 if (was_activated) {
2256 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2258 const LilvPort* port = NULL;
2259 LilvNode* designation = lilv_new_uri(_world.world, uri);
2260 port = lilv_plugin_get_port_by_designation(
2261 plugin, _world.lv2_InputPort, designation);
2262 lilv_node_free(designation);
2264 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2269 static bool lv2_filter (const string& str, void* /*arg*/)
2271 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2273 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2277 LV2World::LV2World()
2278 : world(lilv_world_new())
2279 , _bundle_checked(false)
2281 lilv_world_load_all(world);
2283 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2284 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2285 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2286 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2287 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2288 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2289 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2290 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2291 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2292 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2293 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2294 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2295 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2296 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2297 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2298 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2299 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2300 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2301 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2302 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2303 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2304 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2305 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2306 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2307 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2308 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2309 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2310 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2311 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2312 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2313 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2314 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2315 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2316 units_render = lilv_new_uri(world, LV2_UNITS__render);
2317 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2318 units_db = lilv_new_uri(world, LV2_UNITS__db);
2319 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2320 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2323 LV2World::~LV2World()
2325 lilv_node_free(patch_Message);
2326 lilv_node_free(patch_writable);
2327 lilv_node_free(units_midiNote);
2328 lilv_node_free(units_db);
2329 lilv_node_free(units_unit);
2330 lilv_node_free(units_render);
2331 lilv_node_free(ui_externalkx);
2332 lilv_node_free(ui_external);
2333 lilv_node_free(ui_GtkUI);
2334 lilv_node_free(time_Position);
2335 lilv_node_free(rsz_minimumSize);
2336 lilv_node_free(rdfs_comment);
2337 lilv_node_free(rdfs_label);
2338 lilv_node_free(rdfs_range);
2339 lilv_node_free(midi_MidiEvent);
2340 lilv_node_free(lv2_enumeration);
2341 lilv_node_free(lv2_freewheeling);
2342 lilv_node_free(lv2_toggled);
2343 lilv_node_free(lv2_sampleRate);
2344 lilv_node_free(lv2_reportsLatency);
2345 lilv_node_free(lv2_integer);
2346 lilv_node_free(lv2_inPlaceBroken);
2347 lilv_node_free(lv2_OutputPort);
2348 lilv_node_free(lv2_InputPort);
2349 lilv_node_free(lv2_ControlPort);
2350 lilv_node_free(lv2_AudioPort);
2351 lilv_node_free(ext_notOnGUI);
2352 lilv_node_free(ext_logarithmic);
2353 lilv_node_free(ev_EventPort);
2354 lilv_node_free(atom_supports);
2355 lilv_node_free(atom_eventTransfer);
2356 lilv_node_free(atom_bufferType);
2357 lilv_node_free(atom_Sequence);
2358 lilv_node_free(atom_Chunk);
2359 lilv_node_free(atom_AtomPort);
2360 lilv_world_free(world);
2364 LV2World::load_bundled_plugins(bool verbose)
2366 if (!_bundle_checked) {
2368 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2371 vector<string> plugin_objects;
2372 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2373 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2374 #ifdef PLATFORM_WINDOWS
2375 string uri = "file:///" + *x + "/";
2377 string uri = "file://" + *x + "/";
2379 LilvNode *node = lilv_new_uri(world, uri.c_str());
2380 lilv_world_load_bundle(world, node);
2381 lilv_node_free(node);
2384 _bundle_checked = true;
2388 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2391 _plugin_uri = strdup(plugin_uri);
2394 LV2PluginInfo::~LV2PluginInfo()
2401 LV2PluginInfo::load(Session& session)
2405 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2406 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2407 if (!uri) { throw failed_constructor(); }
2408 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2409 if (!lp) { throw failed_constructor(); }
2410 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2411 lilv_node_free(uri);
2412 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2414 } catch (failed_constructor& err) {
2415 return PluginPtr((Plugin*)0);
2422 LV2PluginInfo::discover()
2425 world.load_bundled_plugins();
2426 _world.load_bundled_plugins(true);
2428 PluginInfoList* plugs = new PluginInfoList;
2429 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2431 if (!Config->get_show_plugin_scan_window()) {
2432 info << "LV2: Discovering " << lilv_plugins_size(plugins) << " plugins" << endmsg;
2435 LILV_FOREACH(plugins, i, plugins) {
2436 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2437 const LilvNode* pun = lilv_plugin_get_uri(p);
2439 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2441 LilvNode* name = lilv_plugin_get_name(p);
2442 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2443 warning << "Ignoring invalid LV2 plugin "
2444 << lilv_node_as_string(lilv_plugin_get_uri(p))
2451 info->name = string(lilv_node_as_string(name));
2452 lilv_node_free(name);
2453 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2455 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2456 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2457 info->category = lilv_node_as_string(label);
2459 LilvNode* author_name = lilv_plugin_get_author_name(p);
2460 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2461 lilv_node_free(author_name);
2463 info->path = "/NOPATH"; // Meaningless for LV2
2465 /* count atom-event-ports that feature
2466 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2468 * TODO: nicely ask drobilla to make a lilv_ call for that
2470 int count_midi_out = 0;
2471 int count_midi_in = 0;
2472 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2473 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2474 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2475 LilvNodes* buffer_types = lilv_port_get_value(
2476 p, port, world.atom_bufferType);
2477 LilvNodes* atom_supports = lilv_port_get_value(
2478 p, port, world.atom_supports);
2480 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2481 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2482 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2485 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2489 lilv_nodes_free(buffer_types);
2490 lilv_nodes_free(atom_supports);
2494 info->n_inputs.set_audio(
2495 lilv_plugin_get_num_ports_of_class(
2496 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2497 info->n_inputs.set_midi(
2498 lilv_plugin_get_num_ports_of_class(
2499 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2502 info->n_outputs.set_audio(
2503 lilv_plugin_get_num_ports_of_class(
2504 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2505 info->n_outputs.set_midi(
2506 lilv_plugin_get_num_ports_of_class(
2507 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2510 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2511 info->index = 0; // Meaningless for LV2
2513 plugs->push_back(info);