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;
153 LilvNode* units_unit;
154 LilvNode* units_render;
155 LilvNode* units_midiNote;
156 LilvNode* patch_writable;
157 LilvNode* patch_Message;
160 bool _bundle_checked;
163 static LV2World _world;
165 /* worker extension */
167 /** Called by the plugin to schedule non-RT work. */
168 static LV2_Worker_Status
169 work_schedule(LV2_Worker_Schedule_Handle handle,
173 LV2Plugin* plugin = (LV2Plugin*)handle;
174 if (plugin->session().engine().freewheeling()) {
175 // Freewheeling, do the work immediately in this (audio) thread
176 return (LV2_Worker_Status)plugin->work(size, data);
178 // Enqueue message for the worker thread
179 return plugin->worker()->schedule(size, data) ?
180 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
184 /** Called by the plugin to respond to non-RT work. */
185 static LV2_Worker_Status
186 work_respond(LV2_Worker_Respond_Handle handle,
190 LV2Plugin* plugin = (LV2Plugin*)handle;
191 if (plugin->session().engine().freewheeling()) {
192 // Freewheeling, respond immediately in this (audio) thread
193 return (LV2_Worker_Status)plugin->work_response(size, data);
195 // Enqueue response for the worker
196 return plugin->worker()->respond(size, data) ?
197 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
204 log_vprintf(LV2_Log_Handle /*handle*/,
210 const int ret = g_vasprintf(&str, fmt, args);
211 if (type == URIMap::instance().urids.log_Error) {
212 error << str << endmsg;
213 } else if (type == URIMap::instance().urids.log_Warning) {
214 warning << str << endmsg;
215 } else if (type == URIMap::instance().urids.log_Note) {
216 info << str << endmsg;
218 // TODO: Toggleable log:Trace message support
223 log_printf(LV2_Log_Handle handle,
225 const char* fmt, ...)
229 const int ret = log_vprintf(handle, type, fmt, args);
234 struct LV2Plugin::Impl {
235 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
240 /** Find the LV2 input port with the given designation.
241 * If found, bufptrs[port_index] will be set to bufptr.
243 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
245 const LilvPlugin* plugin;
247 const LilvNode* ui_type;
250 LilvInstance* instance;
251 const LV2_Worker_Interface* work_iface;
253 LV2_Atom_Forge forge;
254 LV2_Atom_Forge ui_forge;
257 LV2Plugin::LV2Plugin (AudioEngine& engine,
259 const void* c_plugin,
261 : Plugin (engine, session)
267 , _patch_port_in_index((uint32_t)-1)
268 , _patch_port_out_index((uint32_t)-1)
269 , _uri_map(URIMap::instance())
271 init(c_plugin, rate);
274 LV2Plugin::LV2Plugin (const LV2Plugin& other)
280 , _insert_id(other._insert_id)
281 , _patch_port_in_index((uint32_t)-1)
282 , _patch_port_out_index((uint32_t)-1)
283 , _uri_map(URIMap::instance())
285 init(other._impl->plugin, other._sample_rate);
287 for (uint32_t i = 0; i < parameter_count(); ++i) {
288 _control_data[i] = other._shadow_data[i];
289 _shadow_data[i] = other._shadow_data[i];
294 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
296 DEBUG_TRACE(DEBUG::LV2, "init\n");
298 _impl->plugin = (const LilvPlugin*)c_plugin;
300 _impl->ui_type = NULL;
305 _atom_ev_buffers = 0;
307 _bpm_control_port = 0;
308 _freewheel_control_port = 0;
309 _latency_control_port = 0;
310 _next_cycle_start = std::numeric_limits<framepos_t>::max();
311 _next_cycle_speed = 1.0;
312 _block_length = _engine.samples_per_cycle();
313 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
315 _was_activated = false;
316 _has_state_interface = false;
318 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
319 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
320 _make_path_feature.URI = LV2_STATE__makePath;
321 _log_feature.URI = LV2_LOG__log;
322 _work_schedule_feature.URI = LV2_WORKER__schedule;
323 _work_schedule_feature.data = NULL;
324 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
325 _def_state_feature.data = NULL;
327 const LilvPlugin* plugin = _impl->plugin;
329 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
330 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
331 _has_state_interface =
332 // What plugins should have (lv2:extensionData state:Interface)
333 lilv_plugin_has_extension_data(plugin, state_iface_uri)
334 // What some outdated/incorrect ones have
335 || lilv_plugin_has_feature(plugin, state_uri);
336 lilv_node_free(state_uri);
337 lilv_node_free(state_iface_uri);
339 _features = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
340 _features[0] = &_instance_access_feature;
341 _features[1] = &_data_access_feature;
342 _features[2] = &_make_path_feature;
343 _features[3] = _uri_map.uri_map_feature();
344 _features[4] = _uri_map.urid_map_feature();
345 _features[5] = _uri_map.urid_unmap_feature();
346 _features[6] = &_log_feature;
348 unsigned n_features = 7;
349 #ifdef HAVE_LV2_1_2_0
350 _features[n_features++] = &_def_state_feature;
353 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
354 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
356 #ifdef HAVE_LV2_1_2_0
357 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
358 LV2_Options_Option options[] = {
359 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
360 sizeof(int32_t), atom_Int, &_block_length },
361 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
362 sizeof(int32_t), atom_Int, &_block_length },
363 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
364 sizeof(int32_t), atom_Int, &_seq_size },
365 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
368 _options_feature.URI = LV2_OPTIONS__options;
369 _options_feature.data = options;
370 _features[n_features++] = &_options_feature;
373 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
374 sizeof(LV2_State_Make_Path));
375 make_path->handle = this;
376 make_path->path = &lv2_state_make_path;
377 _make_path_feature.data = make_path;
379 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
381 log->printf = &log_printf;
382 log->vprintf = &log_vprintf;
383 _log_feature.data = log;
385 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
386 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
387 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
388 sizeof(LV2_Worker_Schedule));
389 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
390 _worker = new Worker(this, buf_size);
391 schedule->handle = this;
392 schedule->schedule_work = work_schedule;
393 _work_schedule_feature.data = schedule;
394 _features[n_features++] = &_work_schedule_feature;
396 lilv_node_free(worker_schedule);
398 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
399 _impl->name = lilv_plugin_get_name(plugin);
400 _impl->author = lilv_plugin_get_author_name(plugin);
402 if (_impl->instance == 0) {
403 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
404 throw failed_constructor();
407 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
408 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
409 _data_access_feature.data = &_data_access_extension_data;
411 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
412 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
413 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
414 LV2_WORKER__interface);
416 lilv_node_free(worker_iface_uri);
418 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
419 error << string_compose(
420 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
421 lilv_node_as_string(_impl->name)) << endmsg;
422 lilv_node_free(_impl->name);
423 lilv_node_free(_impl->author);
424 throw failed_constructor();
427 #ifdef HAVE_LILV_0_16_0
428 // Load default state
429 LilvState* state = lilv_state_new_from_world(
430 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
431 if (state && _has_state_interface) {
432 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
438 const uint32_t num_ports = this->num_ports();
439 for (uint32_t i = 0; i < num_ports; ++i) {
440 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
442 size_t minimumSize = 0;
444 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
445 flags |= PORT_OUTPUT;
446 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
449 error << string_compose(
450 "LV2: \"%1\" port %2 is neither input nor output",
451 lilv_node_as_string(_impl->name), i) << endmsg;
452 throw failed_constructor();
455 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
456 flags |= PORT_CONTROL;
457 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
459 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
461 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
462 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
463 LilvNodes* buffer_types = lilv_port_get_value(
464 _impl->plugin, port, _world.atom_bufferType);
465 LilvNodes* atom_supports = lilv_port_get_value(
466 _impl->plugin, port, _world.atom_supports);
468 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
469 flags |= PORT_SEQUENCE;
470 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
473 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
474 flags |= PORT_POSITION;
476 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
477 flags |= PORT_PATCHMSG;
478 if (flags & PORT_INPUT) {
479 _patch_port_in_index = i;
481 _patch_port_out_index = i;
485 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
486 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
487 if (min_size && lilv_node_is_int(min_size)) {
488 minimumSize = lilv_node_as_int(min_size);
490 lilv_nodes_free(min_size_v);
491 lilv_nodes_free(buffer_types);
492 lilv_nodes_free(atom_supports);
494 error << string_compose(
495 "LV2: \"%1\" port %2 has no known data type",
496 lilv_node_as_string(_impl->name), i) << endmsg;
497 throw failed_constructor();
500 _port_flags.push_back(flags);
501 _port_minimumSize.push_back(minimumSize);
504 _control_data = new float[num_ports];
505 _shadow_data = new float[num_ports];
506 _defaults = new float[num_ports];
507 _ev_buffers = new LV2_Evbuf*[num_ports];
508 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
510 const bool latent = lilv_plugin_has_latency(plugin);
511 const uint32_t latency_index = (latent)
512 ? lilv_plugin_get_latency_port_index(plugin)
515 // Build an array of pointers to special parameter buffers
516 void*** params = new void**[num_ports];
517 for (uint32_t i = 0; i < num_ports; ++i) {
520 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
521 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
523 for (uint32_t i = 0; i < num_ports; ++i) {
524 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
525 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
527 // Store index in map so we can look up index by symbol
528 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
530 // Get range and default value if applicable
531 if (parameter_is_control(i)) {
533 lilv_port_get_range(plugin, port, &def, NULL, NULL);
534 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
535 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
536 _defaults[i] *= _session.frame_rate ();
540 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
542 if (latent && i == latency_index) {
543 _latency_control_port = &_control_data[i];
544 *_latency_control_port = 0;
547 if (parameter_is_input(i)) {
548 _shadow_data[i] = default_value(i);
550 *params[i] = (void*)&_shadow_data[i];
560 LilvUIs* uis = lilv_plugin_get_uis(plugin);
561 if (lilv_uis_size(uis) > 0) {
563 // Look for embeddable UI
564 LILV_FOREACH(uis, u, uis) {
565 const LilvUI* this_ui = lilv_uis_get(uis, u);
566 const LilvNode* this_ui_type = NULL;
567 if (lilv_ui_is_supported(this_ui,
571 // TODO: Multiple UI support
573 _impl->ui_type = this_ui_type;
578 // Look for Gtk native UI
579 LILV_FOREACH(uis, i, uis) {
580 const LilvUI* ui = lilv_uis_get(uis, i);
581 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
583 _impl->ui_type = _world.ui_GtkUI;
589 // If Gtk UI is not available, try to find external UI
591 LILV_FOREACH(uis, i, uis) {
592 const LilvUI* ui = lilv_uis_get(uis, i);
593 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
595 _impl->ui_type = _world.ui_external;
598 if (lilv_ui_is_a(ui, _world.ui_external)) {
600 _impl->ui_type = _world.ui_external;
606 load_supported_properties(_property_descriptors);
607 allocate_atom_event_buffers();
608 latency_compute_run();
611 LV2Plugin::~LV2Plugin ()
613 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
618 lilv_instance_free(_impl->instance);
619 lilv_node_free(_impl->name);
620 lilv_node_free(_impl->author);
623 free(_make_path_feature.data);
624 free(_work_schedule_feature.data);
630 if (_atom_ev_buffers) {
631 LV2_Evbuf** b = _atom_ev_buffers;
636 free(_atom_ev_buffers);
639 delete [] _control_data;
640 delete [] _shadow_data;
641 delete [] _ev_buffers;
645 LV2Plugin::is_external_ui() const
650 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
654 LV2Plugin::is_external_kx() const
659 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
663 LV2Plugin::ui_is_resizable () const
665 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
666 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
667 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
668 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
670 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
671 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
673 lilv_nodes_free(nrs_matches);
674 lilv_nodes_free(fs_matches);
679 return !fs_matches && !nrs_matches;
683 LV2Plugin::unique_id() const
685 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
689 LV2Plugin::uri() const
691 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
695 LV2Plugin::label() const
697 return lilv_node_as_string(_impl->name);
701 LV2Plugin::name() const
703 return lilv_node_as_string(_impl->name);
707 LV2Plugin::maker() const
709 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
713 LV2Plugin::num_ports() const
715 return lilv_plugin_get_num_ports(_impl->plugin);
719 LV2Plugin::parameter_count() const
721 return lilv_plugin_get_num_ports(_impl->plugin);
725 LV2Plugin::default_value(uint32_t port)
727 return _defaults[port];
731 LV2Plugin::port_symbol(uint32_t index) const
733 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
735 error << name() << ": Invalid port index " << index << endmsg;
738 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
739 return lilv_node_as_string(sym);
743 LV2Plugin::port_index (const char* symbol) const
745 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
746 if (i != _port_indices.end()) {
749 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
755 LV2Plugin::set_parameter(uint32_t which, float val)
757 DEBUG_TRACE(DEBUG::LV2, string_compose(
758 "%1 set parameter %2 to %3\n", name(), which, val));
760 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
761 if (get_parameter (which) == val) {
765 _shadow_data[which] = val;
767 warning << string_compose(
768 _("Illegal parameter number used with plugin \"%1\". "
769 "This is a bug in either %2 or the LV2 plugin <%3>"),
770 name(), PROGRAM_NAME, unique_id()) << endmsg;
773 Plugin::set_parameter(which, val);
777 LV2Plugin::get_parameter(uint32_t which) const
779 if (parameter_is_input(which)) {
780 return (float)_shadow_data[which];
782 return (float)_control_data[which];
788 LV2Plugin::get_docs() const
790 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
792 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
793 lilv_nodes_free(comments);
801 LV2Plugin::get_parameter_docs(uint32_t which) const
803 LilvNodes* comments = lilv_port_get_value(
805 lilv_plugin_get_port_by_index(_impl->plugin, which),
806 _world.rdfs_comment);
809 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
810 lilv_nodes_free(comments);
818 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
821 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
822 if (parameter_is_control(x)) {
834 LV2Plugin::extension_data(const char* uri) const
836 return lilv_instance_get_extension_data(_impl->instance, uri);
840 LV2Plugin::c_plugin()
842 return _impl->plugin;
848 return (const void*)_impl->ui;
852 LV2Plugin::c_ui_type()
854 return (const void*)_impl->ui_type;
857 /** Directory for all plugin state. */
859 LV2Plugin::plugin_dir() const
861 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
864 /** Directory for files created by the plugin (except during save). */
866 LV2Plugin::scratch_dir() const
868 return Glib::build_filename(plugin_dir(), "scratch");
871 /** Directory for snapshots of files in the scratch directory. */
873 LV2Plugin::file_dir() const
875 return Glib::build_filename(plugin_dir(), "files");
878 /** Directory to save state snapshot version @c num into. */
880 LV2Plugin::state_dir(unsigned num) const
882 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
885 /** Implementation of state:makePath for files created at instantiation time.
886 * Note this is not used for files created at save time (Lilv deals with that).
889 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
892 LV2Plugin* me = (LV2Plugin*)handle;
893 if (me->_insert_id == PBD::ID("0")) {
894 warning << string_compose(
895 "File path \"%1\" requested but LV2 %2 has no insert ID",
896 path, me->name()) << endmsg;
897 return g_strdup(path);
900 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
901 const std::string dirname = Glib::path_get_dirname(abs_path);
902 g_mkdir_with_parents(dirname.c_str(), 0744);
904 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
907 return g_strndup(abs_path.c_str(), abs_path.length());
911 LV2Plugin::add_state(XMLNode* root) const
913 assert(_insert_id != PBD::ID("0"));
917 LocaleGuard lg(X_("C"));
919 for (uint32_t i = 0; i < parameter_count(); ++i) {
920 if (parameter_is_input(i) && parameter_is_control(i)) {
921 child = new XMLNode("Port");
922 child->add_property("symbol", port_symbol(i));
923 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
924 child->add_property("value", string(buf));
925 root->add_child_nocopy(*child);
929 if (_has_state_interface) {
930 // Provisionally increment state version and create directory
931 const std::string new_dir = state_dir(++_state_version);
932 g_mkdir_with_parents(new_dir.c_str(), 0744);
934 LilvState* state = lilv_state_new_from_instance(
938 scratch_dir().c_str(),
940 _session.externals_dir().c_str(),
943 const_cast<LV2Plugin*>(this),
947 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
948 lilv_state_save(_world.world,
950 _uri_map.urid_unmap(),
956 lilv_state_free(_impl->state);
957 _impl->state = state;
959 // State is identical, decrement version and nuke directory
960 lilv_state_free(state);
961 PBD::remove_directory(new_dir);
965 root->add_property("state-dir", string_compose("state%1", _state_version));
969 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
971 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
973 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
975 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
983 LV2Plugin::find_presets()
985 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
986 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
987 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
989 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
990 LILV_FOREACH(nodes, i, presets) {
991 const LilvNode* preset = lilv_nodes_get(presets, i);
992 lilv_world_load_resource(_world.world, preset);
993 LilvNode* name = get_value(_world.world, preset, rdfs_label);
995 _presets.insert(std::make_pair(lilv_node_as_string(preset),
996 Plugin::PresetRecord(
997 lilv_node_as_string(preset),
998 lilv_node_as_string(name))));
999 lilv_node_free(name);
1001 warning << string_compose(
1002 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1003 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1004 lilv_node_as_string(preset)) << endmsg;
1007 lilv_nodes_free(presets);
1009 lilv_node_free(rdfs_label);
1010 lilv_node_free(pset_Preset);
1011 lilv_node_free(lv2_appliesTo);
1015 set_port_value(const char* port_symbol,
1021 LV2Plugin* self = (LV2Plugin*)user_data;
1022 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1023 return; // TODO: Support non-float ports
1026 const uint32_t port_index = self->port_index(port_symbol);
1027 if (port_index != (uint32_t)-1) {
1028 self->set_parameter(port_index, *(const float*)value);
1033 LV2Plugin::load_preset(PresetRecord r)
1035 LilvWorld* world = _world.world;
1036 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1037 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1040 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1041 lilv_state_free(state);
1042 Plugin::load_preset(r);
1045 lilv_node_free(pset);
1050 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1055 LV2Plugin *plugin = (LV2Plugin *) user_data;
1057 uint32_t index = plugin->port_index(port_symbol);
1058 if (index != (uint32_t) -1) {
1059 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1061 *size = sizeof(float);
1062 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1063 value = &plugin->_shadow_data[index];
1075 LV2Plugin::do_save_preset(string name)
1077 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1078 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1079 const string base_name = legalize_for_uri(name);
1080 const string file_name = base_name + ".ttl";
1081 const string bundle = Glib::build_filename(
1082 Glib::get_home_dir(),
1083 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1085 LilvState* state = lilv_state_new_from_instance(
1088 _uri_map.urid_map(),
1089 scratch_dir().c_str(), // file_dir
1090 bundle.c_str(), // copy_dir
1091 bundle.c_str(), // link_dir
1092 bundle.c_str(), // save_dir
1093 lv2plugin_get_port_value, // get_value
1094 (void*)this, // user_data
1095 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1096 _features // features
1099 lilv_state_set_label(state, name.c_str());
1101 _world.world, // world
1102 _uri_map.urid_map(), // map
1103 _uri_map.urid_unmap(), // unmap
1105 NULL, // uri (NULL = use file URI)
1106 bundle.c_str(), // dir
1107 file_name.c_str() // filename
1110 lilv_state_free(state);
1112 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1113 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1114 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1115 #ifdef HAVE_LILV_0_21_3
1116 lilv_world_unload_resource(_world.world, node_preset);
1117 lilv_world_unload_bundle(_world.world, node_bundle);
1119 lilv_world_load_bundle(_world.world, node_bundle);
1120 lilv_world_load_resource(_world.world, node_preset);
1121 lilv_node_free(node_bundle);
1122 lilv_node_free(node_preset);
1123 lilv_node_free(plug_name);
1128 LV2Plugin::do_remove_preset(string name)
1130 #ifdef HAVE_LILV_0_21_3
1131 /* Look up preset record by label (FIXME: ick, label as ID) */
1132 const PresetRecord* r = preset_by_label(name);
1137 /* Load a LilvState for the preset. */
1138 LilvWorld* world = _world.world;
1139 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1140 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1142 lilv_node_free(pset);
1146 /* Delete it from the file system. This will remove the preset file and the entry
1147 from the manifest. If this results in an empty manifest (i.e. the
1148 preset is the only thing in the bundle), then the bundle is removed. */
1149 lilv_state_delete(world, state);
1151 lilv_state_free(state);
1152 lilv_node_free(pset);
1154 /* Without lilv_state_delete(), we could delete the preset file, but this
1155 would leave a broken bundle/manifest around, so the preset would still
1156 be visible, but broken. Naively deleting a bundle is too dangerous, so
1157 we simply do not support preset deletion with older Lilv */
1161 LV2Plugin::has_editor() const
1163 return _impl->ui != NULL;
1167 LV2Plugin::has_message_output() const
1169 for (uint32_t i = 0; i < num_ports(); ++i) {
1170 if ((_port_flags[i] & PORT_SEQUENCE) &&
1171 (_port_flags[i] & PORT_OUTPUT)) {
1179 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1183 const uint8_t* body)
1185 const uint32_t buf_size = sizeof(UIMessage) + size;
1186 vector<uint8_t> buf(buf_size);
1188 UIMessage* msg = (UIMessage*)&buf[0];
1190 msg->protocol = protocol;
1192 memcpy(msg + 1, body, size);
1194 return (dest->write(&buf[0], buf_size) == buf_size);
1198 LV2Plugin::write_from_ui(uint32_t index,
1201 const uint8_t* body)
1204 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1205 /* buffer data communication from plugin UI to plugin instance.
1206 * this buffer needs to potentially hold
1207 * (port's minimumSize) * (audio-periods) / (UI-periods)
1210 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1211 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1212 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1214 * it is NOT safe to overflow (msg.size will be misinterpreted)
1216 uint32_t bufsiz = 32768;
1217 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1218 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1220 rbs = max((size_t) bufsiz * 8, rbs);
1221 _from_ui = new RingBuffer<uint8_t>(rbs);
1224 if (!write_to(_from_ui, index, protocol, size, body)) {
1225 error << "Error writing from UI to plugin" << endmsg;
1232 LV2Plugin::write_to_ui(uint32_t index,
1235 const uint8_t* body)
1237 if (!write_to(_to_ui, index, protocol, size, body)) {
1238 error << "Error writing from plugin to UI" << endmsg;
1245 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1247 switch (value.type()) {
1248 case Variant::NOTHING:
1250 case Variant::BEATS:
1251 // No atom type for this, just forge a double
1252 lv2_atom_forge_double(forge, value.get_beats().to_double());
1255 lv2_atom_forge_bool(forge, value.get_bool());
1257 case Variant::DOUBLE:
1258 lv2_atom_forge_double(forge, value.get_double());
1260 case Variant::FLOAT:
1261 lv2_atom_forge_float(forge, value.get_float());
1264 lv2_atom_forge_int(forge, value.get_int());
1267 lv2_atom_forge_long(forge, value.get_long());
1270 lv2_atom_forge_path(
1271 forge, value.get_path().c_str(), value.get_path().size());
1273 case Variant::STRING:
1274 lv2_atom_forge_string(
1275 forge, value.get_string().c_str(), value.get_string().size());
1279 forge, value.get_uri().c_str(), value.get_uri().size());
1284 /** Get a variant type from a URI, return false iff no match found. */
1286 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1288 if (uri == LV2_ATOM__Bool) {
1289 type = Variant::BOOL;
1290 } else if (uri == LV2_ATOM__Double) {
1291 type = Variant::DOUBLE;
1292 } else if (uri == LV2_ATOM__Float) {
1293 type = Variant::FLOAT;
1294 } else if (uri == LV2_ATOM__Int) {
1295 type = Variant::INT;
1296 } else if (uri == LV2_ATOM__Long) {
1297 type = Variant::LONG;
1298 } else if (uri == LV2_ATOM__Path) {
1299 type = Variant::PATH;
1300 } else if (uri == LV2_ATOM__String) {
1301 type = Variant::STRING;
1302 } else if (uri == LV2_ATOM__URI) {
1303 type = Variant::URI;
1311 LV2Plugin::set_property(uint32_t key, const Variant& value)
1313 if (_patch_port_in_index == (uint32_t)-1) {
1314 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1316 } else if (value.type() == Variant::NOTHING) {
1317 error << "LV2: set_property called with void value" << endmsg;
1321 // Set up forge to write to temporary buffer on the stack
1322 LV2_Atom_Forge* forge = &_impl->ui_forge;
1323 LV2_Atom_Forge_Frame frame;
1324 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1326 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1328 // Serialize patch:Set message to set property
1329 #ifdef HAVE_LV2_1_10_0
1330 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1331 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1332 lv2_atom_forge_urid(forge, key);
1333 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1335 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1336 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1337 lv2_atom_forge_urid(forge, key);
1338 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1341 forge_variant(forge, value);
1343 // Write message to UI=>Plugin ring
1344 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1345 write_from_ui(_patch_port_in_index,
1346 _uri_map.urids.atom_eventTransfer,
1347 lv2_atom_total_size(atom),
1348 (const uint8_t*)atom);
1351 const ParameterDescriptor&
1352 LV2Plugin::get_property_descriptor(uint32_t id) const
1354 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1355 if (p != _property_descriptors.end()) {
1358 return Plugin::get_property_descriptor(id);
1362 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1364 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1365 desc.unit = ParameterDescriptor::MIDI_NOTE;
1366 } else if (lilv_nodes_contains(units, _world.units_db)) {
1367 desc.unit = ParameterDescriptor::DB;
1368 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1369 desc.unit = ParameterDescriptor::HZ;
1371 if (lilv_nodes_size(units) > 0) {
1372 const LilvNode* unit = lilv_nodes_get_first(units);
1373 LilvNode* render = get_value(lworld, unit, _world.units_render);
1375 desc.print_fmt = lilv_node_as_string(render);
1376 lilv_node_free(render);
1382 load_parameter_descriptor(LV2World& world,
1383 ParameterDescriptor& desc,
1384 Variant::Type datatype,
1385 const LilvNode* subject)
1387 LilvWorld* lworld = _world.world;
1388 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1389 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1390 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1391 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1392 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1394 desc.label = lilv_node_as_string(label);
1396 if (def && lilv_node_is_float(def)) {
1397 desc.normal = lilv_node_as_float(def);
1399 if (minimum && lilv_node_is_float(minimum)) {
1400 desc.lower = lilv_node_as_float(minimum);
1402 if (maximum && lilv_node_is_float(maximum)) {
1403 desc.upper = lilv_node_as_float(maximum);
1405 load_parameter_descriptor_units(lworld, desc, units);
1406 desc.datatype = datatype;
1407 desc.toggled |= datatype == Variant::BOOL;
1408 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1409 desc.update_steps();
1411 lilv_nodes_free(units);
1412 lilv_node_free(label);
1413 lilv_node_free(def);
1414 lilv_node_free(minimum);
1415 lilv_node_free(maximum);
1419 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1421 LilvWorld* lworld = _world.world;
1422 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1423 LilvNodes* properties = lilv_world_find_nodes(
1424 lworld, subject, _world.patch_writable, NULL);
1425 LILV_FOREACH(nodes, p, properties) {
1426 // Get label and range
1427 const LilvNode* prop = lilv_nodes_get(properties, p);
1428 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1430 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1431 lilv_node_as_uri(prop)) << endmsg;
1435 // Convert range to variant type (TODO: support for multiple range types)
1436 Variant::Type datatype;
1437 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1438 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1439 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1443 // Add description to result
1444 ParameterDescriptor desc;
1445 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1446 desc.datatype = datatype;
1447 load_parameter_descriptor(_world, desc, datatype, prop);
1448 descs.insert(std::make_pair(desc.key, desc));
1450 lilv_node_free(range);
1452 lilv_nodes_free(properties);
1456 LV2Plugin::announce_property_values()
1458 if (_patch_port_in_index == (uint32_t)-1) {
1462 // Set up forge to write to temporary buffer on the stack
1463 LV2_Atom_Forge* forge = &_impl->ui_forge;
1464 LV2_Atom_Forge_Frame frame;
1465 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1467 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1469 // Serialize patch:Get message with no subject (implicitly plugin instance)
1470 #ifdef HAVE_LV2_1_10_0
1471 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1473 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1476 // Write message to UI=>Plugin ring
1477 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1478 write_from_ui(_patch_port_in_index,
1479 _uri_map.urids.atom_eventTransfer,
1480 lv2_atom_total_size(atom),
1481 (const uint8_t*)atom);
1485 LV2Plugin::enable_ui_emission()
1488 /* see note in LV2Plugin::write_from_ui() */
1489 uint32_t bufsiz = 32768;
1490 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1491 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1493 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1494 rbs = max((size_t) bufsiz * 8, rbs);
1495 _to_ui = new RingBuffer<uint8_t>(rbs);
1500 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1506 uint32_t read_space = _to_ui->read_space();
1507 while (read_space > sizeof(UIMessage)) {
1509 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1510 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1513 vector<uint8_t> body(msg.size);
1514 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1515 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1519 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1521 read_space -= sizeof(msg) + msg.size;
1526 LV2Plugin::work(uint32_t size, const void* data)
1528 return _impl->work_iface->work(
1529 _impl->instance->lv2_handle, work_respond, this, size, data);
1533 LV2Plugin::work_response(uint32_t size, const void* data)
1535 return _impl->work_iface->work_response(
1536 _impl->instance->lv2_handle, size, data);
1540 LV2Plugin::set_insert_id(PBD::ID id)
1546 LV2Plugin::set_state(const XMLNode& node, int version)
1549 const XMLProperty* prop;
1550 XMLNodeConstIterator iter;
1555 LocaleGuard lg(X_("C"));
1557 if (node.name() != state_node_name()) {
1558 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1562 #ifndef NO_PLUGIN_STATE
1564 if (version < 3000) {
1565 nodes = node.children("port");
1567 nodes = node.children("Port");
1570 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1574 if ((prop = child->property("symbol")) != 0) {
1575 sym = prop->value().c_str();
1577 warning << _("LV2: port has no symbol, ignored") << endmsg;
1581 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1583 if (i != _port_indices.end()) {
1584 port_id = i->second;
1586 warning << _("LV2: port has unknown index, ignored") << endmsg;
1590 if ((prop = child->property("value")) != 0) {
1591 value = prop->value().c_str();
1593 warning << _("LV2: port has no value, ignored") << endmsg;
1597 set_parameter(port_id, atof(value));
1601 if ((prop = node.property("state-dir")) != 0) {
1602 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1603 error << string_compose(
1604 "LV2: failed to parse state version from \"%1\"",
1605 prop->value()) << endmsg;
1608 std::string state_file = Glib::build_filename(
1610 Glib::build_filename(prop->value(), "state.ttl"));
1612 LilvState* state = lilv_state_new_from_file(
1613 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1615 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1618 latency_compute_run();
1621 return Plugin::set_state(node, version);
1625 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1627 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1629 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1634 LilvNodes* portunits;
1635 LilvNode *def, *min, *max;
1636 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1637 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1639 // TODO: Once we can rely on lilv 0.18.0 being present,
1640 // load_parameter_descriptor() can be used for ports as well
1641 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1642 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1643 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1644 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1645 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1646 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1647 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1648 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1649 load_parameter_descriptor_units(_world.world, desc, portunits);
1651 if (desc.sr_dependent) {
1652 desc.lower *= _session.frame_rate ();
1653 desc.upper *= _session.frame_rate ();
1656 desc.min_unbound = false; // TODO: LV2 extension required
1657 desc.max_unbound = false; // TODO: LV2 extension required
1659 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1660 desc.scale_points = get_scale_points(which);
1662 desc.update_steps();
1664 lilv_node_free(def);
1665 lilv_node_free(min);
1666 lilv_node_free(max);
1667 lilv_nodes_free(portunits);
1673 LV2Plugin::describe_parameter(Evoral::Parameter which)
1675 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1677 if (lilv_port_has_property(_impl->plugin,
1678 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1679 return X_("hidden");
1682 if (lilv_port_has_property(_impl->plugin,
1683 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1684 return X_("hidden");
1687 if (lilv_port_has_property(_impl->plugin,
1688 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1689 return X_("latency");
1692 LilvNode* name = lilv_port_get_name(_impl->plugin,
1693 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1694 string ret(lilv_node_as_string(name));
1695 lilv_node_free(name);
1703 LV2Plugin::signal_latency() const
1705 if (_latency_control_port) {
1706 return (framecnt_t)floor(*_latency_control_port);
1712 set<Evoral::Parameter>
1713 LV2Plugin::automatable() const
1715 set<Evoral::Parameter> ret;
1717 for (uint32_t i = 0; i < parameter_count(); ++i) {
1718 if (parameter_is_input(i) && parameter_is_control(i)) {
1719 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1723 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1724 p != _property_descriptors.end();
1726 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1732 LV2Plugin::activate()
1734 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1736 if (!_was_activated) {
1737 lilv_instance_activate(_impl->instance);
1738 _was_activated = true;
1743 LV2Plugin::deactivate()
1745 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1747 if (_was_activated) {
1748 lilv_instance_deactivate(_impl->instance);
1749 _was_activated = false;
1754 LV2Plugin::cleanup()
1756 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1760 lilv_instance_free(_impl->instance);
1761 _impl->instance = NULL;
1765 LV2Plugin::allocate_atom_event_buffers()
1767 /* reserve local scratch buffers for ATOM event-queues */
1768 const LilvPlugin* p = _impl->plugin;
1770 /* count non-MIDI atom event-ports
1771 * TODO: nicely ask drobilla to make a lilv_ call for that
1773 int count_atom_out = 0;
1774 int count_atom_in = 0;
1775 int minimumSize = 32768; // TODO use a per-port minimum-size
1776 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1777 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1778 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1779 LilvNodes* buffer_types = lilv_port_get_value(
1780 p, port, _world.atom_bufferType);
1781 LilvNodes* atom_supports = lilv_port_get_value(
1782 p, port, _world.atom_supports);
1784 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1785 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1786 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1789 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1792 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1793 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1794 if (min_size && lilv_node_is_int(min_size)) {
1795 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1797 lilv_nodes_free(min_size_v);
1799 lilv_nodes_free(buffer_types);
1800 lilv_nodes_free(atom_supports);
1804 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1805 name(), count_atom_in, count_atom_out));
1807 const int total_atom_buffers = (count_atom_in + count_atom_out);
1808 if (_atom_ev_buffers || total_atom_buffers == 0) {
1812 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1813 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1814 for (int i = 0; i < total_atom_buffers; ++i ) {
1815 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1816 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1818 _atom_ev_buffers[total_atom_buffers] = 0;
1822 /** Write an ardour position/time/tempo/meter as an LV2 event.
1823 * @return true on success.
1826 write_position(LV2_Atom_Forge* forge,
1828 const TempoMetric& t,
1829 Timecode::BBT_Time& bbt,
1831 framepos_t position,
1834 const URIMap::URIDs& urids = URIMap::instance().urids;
1836 uint8_t pos_buf[256];
1837 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1838 LV2_Atom_Forge_Frame frame;
1839 #ifdef HAVE_LV2_1_10_0
1840 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1841 lv2_atom_forge_key(forge, urids.time_frame);
1842 lv2_atom_forge_long(forge, position);
1843 lv2_atom_forge_key(forge, urids.time_speed);
1844 lv2_atom_forge_float(forge, speed);
1845 lv2_atom_forge_key(forge, urids.time_barBeat);
1846 lv2_atom_forge_float(forge, bbt.beats - 1 +
1847 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1848 lv2_atom_forge_key(forge, urids.time_bar);
1849 lv2_atom_forge_long(forge, bbt.bars - 1);
1850 lv2_atom_forge_key(forge, urids.time_beatUnit);
1851 lv2_atom_forge_int(forge, t.meter().note_divisor());
1852 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1853 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1854 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1855 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1857 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1858 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1859 lv2_atom_forge_long(forge, position);
1860 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1861 lv2_atom_forge_float(forge, speed);
1862 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1863 lv2_atom_forge_float(forge, bbt.beats - 1 +
1864 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1865 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1866 lv2_atom_forge_long(forge, bbt.bars - 1);
1867 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1868 lv2_atom_forge_int(forge, t.meter().note_divisor());
1869 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1870 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1871 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1872 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1875 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
1876 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1877 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1878 (const uint8_t*)(atom + 1));
1882 LV2Plugin::connect_and_run(BufferSet& bufs,
1883 ChanMapping in_map, ChanMapping out_map,
1884 pframes_t nframes, framecnt_t offset)
1886 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1887 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1889 cycles_t then = get_cycles();
1891 TempoMap& tmap = _session.tempo_map();
1892 Metrics::const_iterator metric_i = tmap.metrics_end();
1893 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
1895 if (_freewheel_control_port) {
1896 *_freewheel_control_port = _session.engine().freewheeling();
1899 if (_bpm_control_port) {
1900 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1903 ChanCount bufs_count;
1904 bufs_count.set(DataType::AUDIO, 1);
1905 bufs_count.set(DataType::MIDI, 1);
1906 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
1907 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1908 uint32_t const num_ports = parameter_count();
1909 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1911 uint32_t audio_in_index = 0;
1912 uint32_t audio_out_index = 0;
1913 uint32_t midi_in_index = 0;
1914 uint32_t midi_out_index = 0;
1915 uint32_t atom_port_index = 0;
1916 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1918 uint32_t index = nil_index;
1919 PortFlags flags = _port_flags[port_index];
1921 if (flags & PORT_AUDIO) {
1922 if (flags & PORT_INPUT) {
1923 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1925 ? bufs.get_audio(index).data(offset)
1926 : silent_bufs.get_audio(0).data(offset);
1928 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1930 ? bufs.get_audio(index).data(offset)
1931 : scratch_bufs.get_audio(0).data(offset);
1933 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1934 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1935 be necessary, but the mapping is illegal in some cases. Ideally
1936 that should be fixed, but this is easier...
1938 if (flags & PORT_MIDI) {
1939 if (flags & PORT_INPUT) {
1940 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1942 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1944 if (valid && bufs.count().n_midi() > index) {
1945 /* Note, ensure_lv2_bufsize() is not RT safe!
1946 * However free()/alloc() is only called if a
1947 * plugin requires a rsz:minimumSize buffersize
1948 * and the existing buffer if smaller.
1950 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1951 _ev_buffers[port_index] = bufs.get_lv2_midi(
1952 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1954 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1955 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1956 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1960 if (valid && (flags & PORT_INPUT)) {
1961 Timecode::BBT_Time bbt;
1962 if ((flags & PORT_POSITION)) {
1963 if (_session.transport_frame() != _next_cycle_start ||
1964 _session.transport_speed() != _next_cycle_speed) {
1965 // Transport has changed, write position at cycle start
1966 tmap.bbt_time(_session.transport_frame(), bbt);
1967 write_position(&_impl->forge, _ev_buffers[port_index],
1968 tmetric, bbt, _session.transport_speed(),
1969 _session.transport_frame(), 0);
1973 // Get MIDI iterator range (empty range if no MIDI)
1974 MidiBuffer::iterator m = (index != nil_index)
1975 ? bufs.get_midi(index).begin()
1976 : silent_bufs.get_midi(0).end();
1977 MidiBuffer::iterator m_end = (index != nil_index)
1978 ? bufs.get_midi(index).end()
1981 // Now merge MIDI and any transport events into the buffer
1982 const uint32_t type = _uri_map.urids.midi_MidiEvent;
1983 const framepos_t tend = _session.transport_frame() + nframes;
1985 while (m != m_end || (metric_i != tmap.metrics_end() &&
1986 (*metric_i)->frame() < tend)) {
1987 MetricSection* metric = (metric_i != tmap.metrics_end())
1989 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1990 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1991 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1992 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1995 tmetric.set_metric(metric);
1996 bbt = metric->start();
1997 write_position(&_impl->forge, _ev_buffers[port_index],
1998 tmetric, bbt, _session.transport_speed(),
2000 metric->frame() - _session.transport_frame());
2004 } else if (!valid) {
2005 // Nothing we understand or care about, connect to scratch
2006 // see note for midi-buffer size above
2007 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2008 0, _port_minimumSize[port_index]);
2009 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2010 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2013 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2015 continue; // Control port, leave buffer alone
2017 lilv_instance_connect_port(_impl->instance, port_index, buf);
2020 // Read messages from UI and push into appropriate buffers
2022 uint32_t read_space = _from_ui->read_space();
2023 while (read_space > sizeof(UIMessage)) {
2025 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2026 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2029 vector<uint8_t> body(msg.size);
2030 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2031 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2034 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2035 LV2_Evbuf* buf = _ev_buffers[msg.index];
2036 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2037 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2038 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2039 (const uint8_t*)(atom + 1))) {
2040 error << "Failed to write data to LV2 event buffer\n";
2043 error << "Received unknown message type from UI" << endmsg;
2045 read_space -= sizeof(UIMessage) + msg.size;
2052 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2053 PortFlags flags = _port_flags[port_index];
2056 /* TODO ask drobilla about comment
2057 * "Make Ardour event buffers generic so plugins can communicate"
2058 * in libs/ardour/buffer_set.cc:310
2060 * ideally the user could choose which of the following two modes
2061 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2063 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2064 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2065 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2066 * for quite a while at least ;)
2068 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2069 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2070 const uint32_t buf_index = out_map.get(
2071 DataType::MIDI, midi_out_index++, &valid);
2073 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2076 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2077 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2078 const uint32_t buf_index = out_map.get(
2079 DataType::MIDI, midi_out_index++, &valid);
2081 bufs.flush_lv2_midi(true, buf_index);
2086 // Write messages to UI
2087 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2088 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2089 LV2_Evbuf* buf = _ev_buffers[port_index];
2090 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2091 lv2_evbuf_is_valid(i);
2092 i = lv2_evbuf_next(i)) {
2093 uint32_t frames, subframes, type, size;
2095 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2097 // Intercept patch change messages to emit PropertyChanged signal
2098 if ((flags & PORT_PATCHMSG)) {
2099 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2100 if (atom->type == _uri_map.urids.atom_Blank ||
2101 atom->type == _uri_map.urids.atom_Object) {
2102 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2103 if (obj->body.otype == _uri_map.urids.patch_Set) {
2104 const LV2_Atom* property = NULL;
2105 const LV2_Atom* value = NULL;
2106 lv2_atom_object_get(obj,
2107 _uri_map.urids.patch_property, &property,
2108 _uri_map.urids.patch_value, &value,
2111 if (!property || !value ||
2112 property->type != _uri_map.urids.atom_URID ||
2113 value->type != _uri_map.urids.atom_Path) {
2114 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2118 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2119 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2121 // Emit PropertyChanged signal for UI
2122 // TODO: This should emit the control's Changed signal
2123 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2128 if (!_to_ui) continue;
2129 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2130 size + sizeof(LV2_Atom),
2131 data - sizeof(LV2_Atom));
2136 cycles_t now = get_cycles();
2137 set_cycles((uint32_t)(now - then));
2139 // Update expected transport information for next cycle so we can detect changes
2140 _next_cycle_speed = _session.transport_speed();
2141 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2147 LV2Plugin::parameter_is_control(uint32_t param) const
2149 assert(param < _port_flags.size());
2150 return _port_flags[param] & PORT_CONTROL;
2154 LV2Plugin::parameter_is_audio(uint32_t param) const
2156 assert(param < _port_flags.size());
2157 return _port_flags[param] & PORT_AUDIO;
2161 LV2Plugin::parameter_is_event(uint32_t param) const
2163 assert(param < _port_flags.size());
2164 return _port_flags[param] & PORT_EVENT;
2168 LV2Plugin::parameter_is_output(uint32_t param) const
2170 assert(param < _port_flags.size());
2171 return _port_flags[param] & PORT_OUTPUT;
2175 LV2Plugin::parameter_is_input(uint32_t param) const
2177 assert(param < _port_flags.size());
2178 return _port_flags[param] & PORT_INPUT;
2182 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2185 if (param < parameter_count()) {
2186 snprintf(buf, len, "%.3f", get_parameter(param));
2193 boost::shared_ptr<ScalePoints>
2194 LV2Plugin::get_scale_points(uint32_t port_index) const
2196 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2197 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2199 boost::shared_ptr<ScalePoints> ret;
2204 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2206 LILV_FOREACH(scale_points, i, points) {
2207 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2208 const LilvNode* label = lilv_scale_point_get_label(p);
2209 const LilvNode* value = lilv_scale_point_get_value(p);
2210 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2211 ret->insert(make_pair(lilv_node_as_string(label),
2212 lilv_node_as_float(value)));
2216 lilv_scale_points_free(points);
2221 LV2Plugin::run(pframes_t nframes)
2223 uint32_t const N = parameter_count();
2224 for (uint32_t i = 0; i < N; ++i) {
2225 if (parameter_is_control(i) && parameter_is_input(i)) {
2226 _control_data[i] = _shadow_data[i];
2230 lilv_instance_run(_impl->instance, nframes);
2232 if (_impl->work_iface) {
2233 _worker->emit_responses();
2234 if (_impl->work_iface->end_run) {
2235 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2241 LV2Plugin::latency_compute_run()
2243 if (!_latency_control_port) {
2247 // Run the plugin so that it can set its latency parameter
2249 bool was_activated = _was_activated;
2252 uint32_t port_index = 0;
2253 uint32_t in_index = 0;
2254 uint32_t out_index = 0;
2256 // this is done in the main thread. non realtime.
2257 const framecnt_t bufsize = _engine.samples_per_cycle();
2258 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2260 memset(buffer, 0, sizeof(float) * bufsize);
2262 // FIXME: Ensure plugins can handle in-place processing
2266 while (port_index < parameter_count()) {
2267 if (parameter_is_audio(port_index)) {
2268 if (parameter_is_input(port_index)) {
2269 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2271 } else if (parameter_is_output(port_index)) {
2272 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2281 if (was_activated) {
2288 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2290 const LilvPort* port = NULL;
2291 LilvNode* designation = lilv_new_uri(_world.world, uri);
2292 port = lilv_plugin_get_port_by_designation(
2293 plugin, _world.lv2_InputPort, designation);
2294 lilv_node_free(designation);
2296 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2301 static bool lv2_filter (const string& str, void* /*arg*/)
2303 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2305 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2309 LV2World::LV2World()
2310 : world(lilv_world_new())
2311 , _bundle_checked(false)
2313 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2314 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2315 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2316 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2317 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2318 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2319 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2320 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2321 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2322 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2323 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2324 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2325 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2326 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2327 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2328 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2329 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2330 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2331 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2332 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2333 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2334 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2335 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2336 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2337 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2338 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2339 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2340 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2341 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2342 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2343 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2344 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2345 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2346 units_render = lilv_new_uri(world, LV2_UNITS__render);
2347 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2348 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2349 units_db = lilv_new_uri(world, LV2_UNITS__db);
2350 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2351 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2354 LV2World::~LV2World()
2356 lilv_node_free(patch_Message);
2357 lilv_node_free(patch_writable);
2358 lilv_node_free(units_hz);
2359 lilv_node_free(units_midiNote);
2360 lilv_node_free(units_db);
2361 lilv_node_free(units_unit);
2362 lilv_node_free(units_render);
2363 lilv_node_free(ui_externalkx);
2364 lilv_node_free(ui_external);
2365 lilv_node_free(ui_GtkUI);
2366 lilv_node_free(time_Position);
2367 lilv_node_free(rsz_minimumSize);
2368 lilv_node_free(rdfs_comment);
2369 lilv_node_free(rdfs_label);
2370 lilv_node_free(rdfs_range);
2371 lilv_node_free(midi_MidiEvent);
2372 lilv_node_free(lv2_enumeration);
2373 lilv_node_free(lv2_freewheeling);
2374 lilv_node_free(lv2_toggled);
2375 lilv_node_free(lv2_sampleRate);
2376 lilv_node_free(lv2_reportsLatency);
2377 lilv_node_free(lv2_integer);
2378 lilv_node_free(lv2_inPlaceBroken);
2379 lilv_node_free(lv2_OutputPort);
2380 lilv_node_free(lv2_InputPort);
2381 lilv_node_free(lv2_ControlPort);
2382 lilv_node_free(lv2_AudioPort);
2383 lilv_node_free(ext_notOnGUI);
2384 lilv_node_free(ext_logarithmic);
2385 lilv_node_free(ev_EventPort);
2386 lilv_node_free(atom_supports);
2387 lilv_node_free(atom_eventTransfer);
2388 lilv_node_free(atom_bufferType);
2389 lilv_node_free(atom_Sequence);
2390 lilv_node_free(atom_Chunk);
2391 lilv_node_free(atom_AtomPort);
2392 lilv_world_free(world);
2396 LV2World::load_bundled_plugins(bool verbose)
2398 if (!_bundle_checked) {
2400 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2403 vector<string> plugin_objects;
2404 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2405 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2406 #ifdef PLATFORM_WINDOWS
2407 string uri = "file:///" + *x + "/";
2409 string uri = "file://" + *x + "/";
2411 LilvNode *node = lilv_new_uri(world, uri.c_str());
2412 lilv_world_load_bundle(world, node);
2413 lilv_node_free(node);
2416 lilv_world_load_all(world);
2417 _bundle_checked = true;
2421 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2424 _plugin_uri = strdup(plugin_uri);
2427 LV2PluginInfo::~LV2PluginInfo()
2434 LV2PluginInfo::load(Session& session)
2438 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2439 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2440 if (!uri) { throw failed_constructor(); }
2441 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2442 if (!lp) { throw failed_constructor(); }
2443 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2444 lilv_node_free(uri);
2445 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2447 } catch (failed_constructor& err) {
2448 return PluginPtr((Plugin*)0);
2455 LV2PluginInfo::discover()
2458 world.load_bundled_plugins();
2459 _world.load_bundled_plugins(true);
2461 PluginInfoList* plugs = new PluginInfoList;
2462 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2464 LILV_FOREACH(plugins, i, plugins) {
2465 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2466 const LilvNode* pun = lilv_plugin_get_uri(p);
2468 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2470 LilvNode* name = lilv_plugin_get_name(p);
2471 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2472 warning << "Ignoring invalid LV2 plugin "
2473 << lilv_node_as_string(lilv_plugin_get_uri(p))
2480 info->name = string(lilv_node_as_string(name));
2481 lilv_node_free(name);
2482 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2484 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2485 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2486 info->category = lilv_node_as_string(label);
2488 LilvNode* author_name = lilv_plugin_get_author_name(p);
2489 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2490 lilv_node_free(author_name);
2492 info->path = "/NOPATH"; // Meaningless for LV2
2494 /* count atom-event-ports that feature
2495 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2497 * TODO: nicely ask drobilla to make a lilv_ call for that
2499 int count_midi_out = 0;
2500 int count_midi_in = 0;
2501 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2502 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2503 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2504 LilvNodes* buffer_types = lilv_port_get_value(
2505 p, port, world.atom_bufferType);
2506 LilvNodes* atom_supports = lilv_port_get_value(
2507 p, port, world.atom_supports);
2509 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2510 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2511 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2514 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2518 lilv_nodes_free(buffer_types);
2519 lilv_nodes_free(atom_supports);
2523 info->n_inputs.set_audio(
2524 lilv_plugin_get_num_ports_of_class(
2525 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2526 info->n_inputs.set_midi(
2527 lilv_plugin_get_num_ports_of_class(
2528 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2531 info->n_outputs.set_audio(
2532 lilv_plugin_get_num_ports_of_class(
2533 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2534 info->n_outputs.set_midi(
2535 lilv_plugin_get_num_ports_of_class(
2536 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2539 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2540 info->index = 0; // Meaningless for LV2
2542 plugs->push_back(info);