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 "pbd/gstdio_compat.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;
158 #ifdef HAVE_LV2_1_2_0
159 LilvNode* bufz_powerOf2BlockLength;
160 LilvNode* bufz_fixedBlockLength;
161 LilvNode* bufz_nominalBlockLength;
164 #ifdef HAVE_LV2_1_10_0
166 LilvNode* atom_float;
167 LilvNode* atom_object; // new in 1.8
168 LilvNode* atom_vector;
171 LilvNode* lv2_noSampleAccurateCtrl;
172 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
173 LilvNode* auto_automation_control; // atom:supports
174 LilvNode* auto_automation_controlled; // lv2:portProperty
178 bool _bundle_checked;
181 static LV2World _world;
183 /* worker extension */
185 /** Called by the plugin to schedule non-RT work. */
186 static LV2_Worker_Status
187 work_schedule(LV2_Worker_Schedule_Handle handle,
191 LV2Plugin* plugin = (LV2Plugin*)handle;
192 if (plugin->session().engine().freewheeling()) {
193 // Freewheeling, do the work immediately in this (audio) thread
194 return (LV2_Worker_Status)plugin->work(size, data);
196 // Enqueue message for the worker thread
197 return plugin->worker()->schedule(size, data) ?
198 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
202 /** Called by the plugin to respond to non-RT work. */
203 static LV2_Worker_Status
204 work_respond(LV2_Worker_Respond_Handle handle,
208 LV2Plugin* plugin = (LV2Plugin*)handle;
209 if (plugin->session().engine().freewheeling()) {
210 // Freewheeling, respond immediately in this (audio) thread
211 return (LV2_Worker_Status)plugin->work_response(size, data);
213 // Enqueue response for the worker
214 return plugin->worker()->respond(size, data) ?
215 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
222 log_vprintf(LV2_Log_Handle /*handle*/,
228 const int ret = g_vasprintf(&str, fmt, args);
229 if (type == URIMap::instance().urids.log_Error) {
230 error << str << endmsg;
231 } else if (type == URIMap::instance().urids.log_Warning) {
232 warning << str << endmsg;
233 } else if (type == URIMap::instance().urids.log_Note) {
234 info << str << endmsg;
236 // TODO: Toggleable log:Trace message support
241 log_printf(LV2_Log_Handle handle,
243 const char* fmt, ...)
247 const int ret = log_vprintf(handle, type, fmt, args);
252 struct LV2Plugin::Impl {
253 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
255 #ifdef HAVE_LV2_1_2_0
260 #ifdef HAVE_LV2_1_2_0
265 /** Find the LV2 input port with the given designation.
266 * If found, bufptrs[port_index] will be set to bufptr.
268 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
270 const LilvPlugin* plugin;
272 const LilvNode* ui_type;
275 LilvInstance* instance;
276 const LV2_Worker_Interface* work_iface;
277 #ifdef HAVE_LV2_1_2_0
278 const LV2_Options_Interface* opts_iface;
281 LV2_Atom_Forge forge;
282 LV2_Atom_Forge ui_forge;
283 int32_t block_length;
284 #ifdef HAVE_LV2_1_2_0
285 LV2_Options_Option* options;
289 LV2Plugin::LV2Plugin (AudioEngine& engine,
291 const void* c_plugin,
293 : Plugin (engine, session)
299 , _patch_port_in_index((uint32_t)-1)
300 , _patch_port_out_index((uint32_t)-1)
301 , _uri_map(URIMap::instance())
302 , _no_sample_accurate_ctrl (false)
304 init(c_plugin, rate);
307 LV2Plugin::LV2Plugin (const LV2Plugin& other)
313 , _insert_id(other._insert_id)
314 , _patch_port_in_index((uint32_t)-1)
315 , _patch_port_out_index((uint32_t)-1)
316 , _uri_map(URIMap::instance())
317 , _no_sample_accurate_ctrl (false)
319 init(other._impl->plugin, other._sample_rate);
321 for (uint32_t i = 0; i < parameter_count(); ++i) {
322 _control_data[i] = other._shadow_data[i];
323 _shadow_data[i] = other._shadow_data[i];
328 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
330 DEBUG_TRACE(DEBUG::LV2, "init\n");
332 _impl->plugin = (const LilvPlugin*)c_plugin;
334 _impl->ui_type = NULL;
339 _atom_ev_buffers = 0;
341 _bpm_control_port = 0;
342 _freewheel_control_port = 0;
343 _latency_control_port = 0;
344 _next_cycle_start = std::numeric_limits<framepos_t>::max();
345 _next_cycle_speed = 1.0;
346 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
348 _was_activated = false;
349 _has_state_interface = false;
350 _can_write_automation = false;
351 _impl->block_length = _session.get_block_size();
353 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
354 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
355 _make_path_feature.URI = LV2_STATE__makePath;
356 _log_feature.URI = LV2_LOG__log;
357 _work_schedule_feature.URI = LV2_WORKER__schedule;
358 _work_schedule_feature.data = NULL;
359 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
360 _def_state_feature.data = NULL;
362 const LilvPlugin* plugin = _impl->plugin;
364 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
365 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
366 _has_state_interface =
367 // What plugins should have (lv2:extensionData state:Interface)
368 lilv_plugin_has_extension_data(plugin, state_iface_uri)
369 // What some outdated/incorrect ones have
370 || lilv_plugin_has_feature(plugin, state_uri);
371 lilv_node_free(state_uri);
372 lilv_node_free(state_iface_uri);
374 _features = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
375 _features[0] = &_instance_access_feature;
376 _features[1] = &_data_access_feature;
377 _features[2] = &_make_path_feature;
378 _features[3] = _uri_map.uri_map_feature();
379 _features[4] = _uri_map.urid_map_feature();
380 _features[5] = _uri_map.urid_unmap_feature();
381 _features[6] = &_log_feature;
383 unsigned n_features = 7;
384 #ifdef HAVE_LV2_1_2_0
385 _features[n_features++] = &_def_state_feature;
388 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
389 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
391 #ifdef HAVE_LV2_1_2_0
392 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
393 static const int32_t _min_block_length = 1; // may happen during split-cycles
394 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
395 /* Consider updating max-block-size whenever the buffersize changes.
396 * It requires re-instantiating the plugin (which is a non-realtime operation),
397 * so it should be done lightly and only for plugins that require it.
399 * given that the block-size can change at any time (split-cycles) ardour currently
400 * does not support plugins that require bufz_fixedBlockLength.
402 LV2_Options_Option options[] = {
403 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
404 sizeof(int32_t), atom_Int, &_min_block_length },
405 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
406 sizeof(int32_t), atom_Int, &_max_block_length },
407 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
408 sizeof(int32_t), atom_Int, &_seq_size },
409 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
410 sizeof(int32_t), atom_Int, &_impl->block_length },
411 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
414 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
415 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
417 _options_feature.URI = LV2_OPTIONS__options;
418 _options_feature.data = _impl->options;
419 _features[n_features++] = &_options_feature;
422 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
423 sizeof(LV2_State_Make_Path));
424 make_path->handle = this;
425 make_path->path = &lv2_state_make_path;
426 _make_path_feature.data = make_path;
428 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
430 log->printf = &log_printf;
431 log->vprintf = &log_vprintf;
432 _log_feature.data = log;
434 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
435 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
436 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
437 sizeof(LV2_Worker_Schedule));
438 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
439 _worker = new Worker(this, buf_size);
440 schedule->handle = this;
441 schedule->schedule_work = work_schedule;
442 _work_schedule_feature.data = schedule;
443 _features[n_features++] = &_work_schedule_feature;
445 lilv_node_free(worker_schedule);
447 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
448 _impl->name = lilv_plugin_get_name(plugin);
449 _impl->author = lilv_plugin_get_author_name(plugin);
451 if (_impl->instance == 0) {
452 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
453 throw failed_constructor();
456 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
457 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
458 _data_access_feature.data = &_data_access_extension_data;
460 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
461 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
462 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
463 LV2_WORKER__interface);
465 lilv_node_free(worker_iface_uri);
468 #ifdef HAVE_LV2_1_2_0
469 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
470 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
471 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
472 LV2_OPTIONS__interface);
474 lilv_node_free(options_iface_uri);
477 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
478 error << string_compose(
479 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
480 lilv_node_as_string(_impl->name)) << endmsg;
481 lilv_node_free(_impl->name);
482 lilv_node_free(_impl->author);
483 throw failed_constructor();
486 #ifdef HAVE_LV2_1_2_0
487 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
488 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
489 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
491 error << string_compose(
492 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
493 lilv_node_as_string(_impl->name)) << endmsg;
494 lilv_node_free(_impl->name);
495 lilv_node_free(_impl->author);
496 lilv_nodes_free(required_features);
497 throw failed_constructor();
499 lilv_nodes_free(required_features);
503 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
504 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
505 _no_sample_accurate_ctrl = true;
507 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
508 _can_write_automation = true;
510 lilv_nodes_free(optional_features);
513 #ifdef HAVE_LILV_0_16_0
514 // Load default state
515 LilvState* state = lilv_state_new_from_world(
516 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
517 if (state && _has_state_interface) {
518 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
520 lilv_state_free(state);
525 const uint32_t num_ports = this->num_ports();
526 for (uint32_t i = 0; i < num_ports; ++i) {
527 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
529 size_t minimumSize = 0;
531 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
532 flags |= PORT_OUTPUT;
533 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
536 error << string_compose(
537 "LV2: \"%1\" port %2 is neither input nor output",
538 lilv_node_as_string(_impl->name), i) << endmsg;
539 throw failed_constructor();
542 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
543 flags |= PORT_CONTROL;
544 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
546 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
548 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
549 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
550 LilvNodes* buffer_types = lilv_port_get_value(
551 _impl->plugin, port, _world.atom_bufferType);
552 LilvNodes* atom_supports = lilv_port_get_value(
553 _impl->plugin, port, _world.atom_supports);
555 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
556 flags |= PORT_SEQUENCE;
557 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
560 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
561 flags |= PORT_POSITION;
564 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
565 flags |= PORT_AUTOCTRL;
568 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
569 flags |= PORT_PATCHMSG;
570 if (flags & PORT_INPUT) {
571 _patch_port_in_index = i;
573 _patch_port_out_index = i;
577 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
578 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
579 if (min_size && lilv_node_is_int(min_size)) {
580 minimumSize = lilv_node_as_int(min_size);
582 lilv_nodes_free(min_size_v);
583 lilv_nodes_free(buffer_types);
584 lilv_nodes_free(atom_supports);
586 error << string_compose(
587 "LV2: \"%1\" port %2 has no known data type",
588 lilv_node_as_string(_impl->name), i) << endmsg;
589 throw failed_constructor();
593 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
594 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
595 flags |= PORT_CTRLED;
600 _port_flags.push_back(flags);
601 _port_minimumSize.push_back(minimumSize);
604 _control_data = new float[num_ports];
605 _shadow_data = new float[num_ports];
606 _defaults = new float[num_ports];
607 _ev_buffers = new LV2_Evbuf*[num_ports];
608 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
610 const bool latent = lilv_plugin_has_latency(plugin);
611 const uint32_t latency_index = (latent)
612 ? lilv_plugin_get_latency_port_index(plugin)
615 // Build an array of pointers to special parameter buffers
616 void*** params = new void**[num_ports];
617 for (uint32_t i = 0; i < num_ports; ++i) {
620 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
621 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
623 for (uint32_t i = 0; i < num_ports; ++i) {
624 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
625 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
627 // Store index in map so we can look up index by symbol
628 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
630 // Get range and default value if applicable
631 if (parameter_is_control(i)) {
633 lilv_port_get_range(plugin, port, &def, NULL, NULL);
634 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
635 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
636 _defaults[i] *= _session.frame_rate ();
640 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
642 if (latent && i == latency_index) {
643 _latency_control_port = &_control_data[i];
644 *_latency_control_port = 0;
647 if (parameter_is_input(i)) {
648 _shadow_data[i] = default_value(i);
650 *params[i] = (void*)&_shadow_data[i];
660 LilvUIs* uis = lilv_plugin_get_uis(plugin);
661 if (lilv_uis_size(uis) > 0) {
663 // Look for embeddable UI
664 LILV_FOREACH(uis, u, uis) {
665 const LilvUI* this_ui = lilv_uis_get(uis, u);
666 const LilvNode* this_ui_type = NULL;
667 if (lilv_ui_is_supported(this_ui,
671 // TODO: Multiple UI support
673 _impl->ui_type = this_ui_type;
678 // Look for Gtk native UI
679 LILV_FOREACH(uis, i, uis) {
680 const LilvUI* ui = lilv_uis_get(uis, i);
681 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
683 _impl->ui_type = _world.ui_GtkUI;
689 // If Gtk UI is not available, try to find external UI
691 LILV_FOREACH(uis, i, uis) {
692 const LilvUI* ui = lilv_uis_get(uis, i);
693 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
695 _impl->ui_type = _world.ui_external;
698 if (lilv_ui_is_a(ui, _world.ui_external)) {
700 _impl->ui_type = _world.ui_external;
706 load_supported_properties(_property_descriptors);
707 allocate_atom_event_buffers();
708 latency_compute_run();
712 LV2Plugin::set_block_size (pframes_t nframes)
714 #ifdef HAVE_LV2_1_2_0
715 if (_impl->opts_iface) {
716 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
717 _impl->block_length = nframes;
718 LV2_Options_Option block_size_option = {
719 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
720 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
722 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
729 LV2Plugin::requires_fixed_sized_buffers () const
731 /* This controls if Ardour will split the plugin's run()
732 * on automation events in order to pass sample-accurate automation
733 * via standard control-ports.
735 * When returning true Ardour will *not* sub-divide the process-cycle.
736 * Automation events that happen between cycle-start and cycle-end will be
737 * ignored (ctrl values are interpolated to cycle-start).
738 * NB. Atom Sequences are still sample accurate.
740 * Note: This does not guarantee a fixed block-size.
741 * e.g The process cycle may be split when looping, also
742 * the period-size may change any time: see set_block_size()
744 if (get_info()->n_inputs.n_midi() > 0) {
745 /* we don't yet implement midi buffer offsets (for split cycles).
746 * Also connect_and_run() also uses _session.transport_frame() directly
747 * (for BBT) which is not offset for plugin cycle split.
751 return _no_sample_accurate_ctrl;
754 LV2Plugin::~LV2Plugin ()
756 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
761 lilv_instance_free(_impl->instance);
762 lilv_state_free(_impl->state);
763 lilv_node_free(_impl->name);
764 lilv_node_free(_impl->author);
765 #ifdef HAVE_LV2_1_2_0
766 free(_impl->options);
770 free(_make_path_feature.data);
771 free(_work_schedule_feature.data);
777 if (_atom_ev_buffers) {
778 LV2_Evbuf** b = _atom_ev_buffers;
783 free(_atom_ev_buffers);
786 delete [] _control_data;
787 delete [] _shadow_data;
789 delete [] _ev_buffers;
793 LV2Plugin::is_external_ui() const
798 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
802 LV2Plugin::is_external_kx() const
807 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
811 LV2Plugin::ui_is_resizable () const
813 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
814 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
815 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
816 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
818 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
819 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
821 lilv_nodes_free(nrs_matches);
822 lilv_nodes_free(fs_matches);
827 return !fs_matches && !nrs_matches;
831 LV2Plugin::unique_id() const
833 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
837 LV2Plugin::uri() const
839 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
843 LV2Plugin::label() const
845 return lilv_node_as_string(_impl->name);
849 LV2Plugin::name() const
851 return lilv_node_as_string(_impl->name);
855 LV2Plugin::maker() const
857 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
861 LV2Plugin::num_ports() const
863 return lilv_plugin_get_num_ports(_impl->plugin);
867 LV2Plugin::parameter_count() const
869 return lilv_plugin_get_num_ports(_impl->plugin);
873 LV2Plugin::default_value(uint32_t port)
875 return _defaults[port];
879 LV2Plugin::port_symbol(uint32_t index) const
881 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
883 error << name() << ": Invalid port index " << index << endmsg;
886 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
887 return lilv_node_as_string(sym);
891 LV2Plugin::port_index (const char* symbol) const
893 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
894 if (i != _port_indices.end()) {
897 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
903 LV2Plugin::set_parameter(uint32_t which, float val)
905 DEBUG_TRACE(DEBUG::LV2, string_compose(
906 "%1 set parameter %2 to %3\n", name(), which, val));
908 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
909 if (get_parameter (which) == val) {
913 _shadow_data[which] = val;
915 warning << string_compose(
916 _("Illegal parameter number used with plugin \"%1\". "
917 "This is a bug in either %2 or the LV2 plugin <%3>"),
918 name(), PROGRAM_NAME, unique_id()) << endmsg;
921 Plugin::set_parameter(which, val);
925 LV2Plugin::get_parameter(uint32_t which) const
927 if (parameter_is_input(which)) {
928 return (float)_shadow_data[which];
930 return (float)_control_data[which];
936 LV2Plugin::get_docs() const
938 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
940 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
941 lilv_nodes_free(comments);
949 LV2Plugin::get_parameter_docs(uint32_t which) const
951 LilvNodes* comments = lilv_port_get_value(
953 lilv_plugin_get_port_by_index(_impl->plugin, which),
954 _world.rdfs_comment);
957 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
958 lilv_nodes_free(comments);
966 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
969 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
970 if (parameter_is_control(x)) {
982 LV2Plugin::extension_data(const char* uri) const
984 return lilv_instance_get_extension_data(_impl->instance, uri);
988 LV2Plugin::c_plugin()
990 return _impl->plugin;
996 return (const void*)_impl->ui;
1000 LV2Plugin::c_ui_type()
1002 return (const void*)_impl->ui_type;
1005 /** Directory for all plugin state. */
1007 LV2Plugin::plugin_dir() const
1009 if (!_plugin_state_dir.empty ()){
1010 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1012 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1016 /** Directory for files created by the plugin (except during save). */
1018 LV2Plugin::scratch_dir() const
1020 return Glib::build_filename(plugin_dir(), "scratch");
1023 /** Directory for snapshots of files in the scratch directory. */
1025 LV2Plugin::file_dir() const
1027 return Glib::build_filename(plugin_dir(), "files");
1030 /** Directory to save state snapshot version @c num into. */
1032 LV2Plugin::state_dir(unsigned num) const
1034 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1037 /** Implementation of state:makePath for files created at instantiation time.
1038 * Note this is not used for files created at save time (Lilv deals with that).
1041 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1044 LV2Plugin* me = (LV2Plugin*)handle;
1045 if (me->_insert_id == PBD::ID("0")) {
1046 warning << string_compose(
1047 "File path \"%1\" requested but LV2 %2 has no insert ID",
1048 path, me->name()) << endmsg;
1049 return g_strdup(path);
1052 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1053 const std::string dirname = Glib::path_get_dirname(abs_path);
1054 g_mkdir_with_parents(dirname.c_str(), 0744);
1056 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1059 return g_strndup(abs_path.c_str(), abs_path.length());
1063 LV2Plugin::add_state(XMLNode* root) const
1065 assert(_insert_id != PBD::ID("0"));
1069 LocaleGuard lg(X_("C"));
1071 for (uint32_t i = 0; i < parameter_count(); ++i) {
1072 if (parameter_is_input(i) && parameter_is_control(i)) {
1073 child = new XMLNode("Port");
1074 child->add_property("symbol", port_symbol(i));
1075 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1076 child->add_property("value", string(buf));
1077 root->add_child_nocopy(*child);
1081 if (!_plugin_state_dir.empty()) {
1082 root->add_property("template-dir", _plugin_state_dir);
1085 if (_has_state_interface) {
1086 // Provisionally increment state version and create directory
1087 const std::string new_dir = state_dir(++_state_version);
1088 g_mkdir_with_parents(new_dir.c_str(), 0744);
1090 LilvState* state = lilv_state_new_from_instance(
1093 _uri_map.urid_map(),
1094 scratch_dir().c_str(),
1096 _session.externals_dir().c_str(),
1099 const_cast<LV2Plugin*>(this),
1103 if (!_plugin_state_dir.empty()
1105 || !lilv_state_equals(state, _impl->state)) {
1106 lilv_state_save(_world.world,
1107 _uri_map.urid_map(),
1108 _uri_map.urid_unmap(),
1114 if (_plugin_state_dir.empty()) {
1115 // normal session save
1116 lilv_state_free(_impl->state);
1117 _impl->state = state;
1119 // template save (dedicated state-dir)
1120 lilv_state_free(state);
1123 // State is identical, decrement version and nuke directory
1124 lilv_state_free(state);
1125 PBD::remove_directory(new_dir);
1129 root->add_property("state-dir", string_compose("state%1", _state_version));
1133 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1135 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1137 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1139 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1140 lilv_nodes_free(vs);
1147 LV2Plugin::find_presets()
1149 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1150 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1151 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1153 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1154 LILV_FOREACH(nodes, i, presets) {
1155 const LilvNode* preset = lilv_nodes_get(presets, i);
1156 lilv_world_load_resource(_world.world, preset);
1157 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1158 bool userpreset = true; // TODO
1160 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1161 Plugin::PresetRecord(
1162 lilv_node_as_string(preset),
1163 lilv_node_as_string(name),
1165 lilv_node_free(name);
1167 warning << string_compose(
1168 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1169 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1170 lilv_node_as_string(preset)) << endmsg;
1173 lilv_nodes_free(presets);
1175 lilv_node_free(rdfs_label);
1176 lilv_node_free(pset_Preset);
1177 lilv_node_free(lv2_appliesTo);
1181 set_port_value(const char* port_symbol,
1187 LV2Plugin* self = (LV2Plugin*)user_data;
1188 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1189 return; // TODO: Support non-float ports
1192 const uint32_t port_index = self->port_index(port_symbol);
1193 if (port_index != (uint32_t)-1) {
1194 self->set_parameter(port_index, *(const float*)value);
1199 LV2Plugin::load_preset(PresetRecord r)
1201 LilvWorld* world = _world.world;
1202 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1203 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1206 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1207 lilv_state_free(state);
1208 Plugin::load_preset(r);
1211 lilv_node_free(pset);
1216 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1221 LV2Plugin *plugin = (LV2Plugin *) user_data;
1223 uint32_t index = plugin->port_index(port_symbol);
1224 if (index != (uint32_t) -1) {
1225 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1227 *size = sizeof(float);
1228 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1229 value = &plugin->_shadow_data[index];
1241 LV2Plugin::do_save_preset(string name)
1243 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1244 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1245 const string base_name = legalize_for_uri(name);
1246 const string file_name = base_name + ".ttl";
1247 const string bundle = Glib::build_filename(
1248 Glib::get_home_dir(),
1249 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1251 #ifdef HAVE_LILV_0_21_3
1252 /* delete reference to old preset (if any) */
1253 const PresetRecord* r = preset_by_label(name);
1255 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1257 lilv_world_unload_resource (_world.world, pset);
1258 lilv_node_free(pset);
1263 LilvState* state = lilv_state_new_from_instance(
1266 _uri_map.urid_map(),
1267 scratch_dir().c_str(), // file_dir
1268 bundle.c_str(), // copy_dir
1269 bundle.c_str(), // link_dir
1270 bundle.c_str(), // save_dir
1271 lv2plugin_get_port_value, // get_value
1272 (void*)this, // user_data
1273 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1274 _features // features
1277 lilv_state_set_label(state, name.c_str());
1279 _world.world, // world
1280 _uri_map.urid_map(), // map
1281 _uri_map.urid_unmap(), // unmap
1283 NULL, // uri (NULL = use file URI)
1284 bundle.c_str(), // dir
1285 file_name.c_str() // filename
1288 lilv_state_free(state);
1290 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1291 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1292 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1293 #ifdef HAVE_LILV_0_21_3
1294 lilv_world_unload_resource(_world.world, node_preset);
1295 lilv_world_unload_bundle(_world.world, node_bundle);
1297 lilv_world_load_bundle(_world.world, node_bundle);
1298 lilv_world_load_resource(_world.world, node_preset);
1299 lilv_node_free(node_bundle);
1300 lilv_node_free(node_preset);
1301 lilv_node_free(plug_name);
1306 LV2Plugin::do_remove_preset(string name)
1308 #ifdef HAVE_LILV_0_21_3
1309 /* Look up preset record by label (FIXME: ick, label as ID) */
1310 const PresetRecord* r = preset_by_label(name);
1315 /* Load a LilvState for the preset. */
1316 LilvWorld* world = _world.world;
1317 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1318 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1320 lilv_node_free(pset);
1324 /* Unload preset from world. */
1325 lilv_world_unload_resource(world, pset);
1327 /* Delete it from the file system. This will remove the preset file and the entry
1328 from the manifest. If this results in an empty manifest (i.e. the
1329 preset is the only thing in the bundle), then the bundle is removed. */
1330 lilv_state_delete(world, state);
1332 lilv_state_free(state);
1333 lilv_node_free(pset);
1335 /* Without lilv_state_delete(), we could delete the preset file, but this
1336 would leave a broken bundle/manifest around, so the preset would still
1337 be visible, but broken. Naively deleting a bundle is too dangerous, so
1338 we simply do not support preset deletion with older Lilv */
1342 LV2Plugin::has_editor() const
1344 return _impl->ui != NULL;
1348 LV2Plugin::has_message_output() const
1350 for (uint32_t i = 0; i < num_ports(); ++i) {
1351 if ((_port_flags[i] & PORT_SEQUENCE) &&
1352 (_port_flags[i] & PORT_OUTPUT)) {
1360 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1364 const uint8_t* body)
1366 const uint32_t buf_size = sizeof(UIMessage) + size;
1367 vector<uint8_t> buf(buf_size);
1369 UIMessage* msg = (UIMessage*)&buf[0];
1371 msg->protocol = protocol;
1373 memcpy(msg + 1, body, size);
1375 return (dest->write(&buf[0], buf_size) == buf_size);
1379 LV2Plugin::write_from_ui(uint32_t index,
1382 const uint8_t* body)
1385 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1386 /* buffer data communication from plugin UI to plugin instance.
1387 * this buffer needs to potentially hold
1388 * (port's minimumSize) * (audio-periods) / (UI-periods)
1391 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1392 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1393 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1395 * it is NOT safe to overflow (msg.size will be misinterpreted)
1397 uint32_t bufsiz = 32768;
1398 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1399 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1401 rbs = max((size_t) bufsiz * 8, rbs);
1402 _from_ui = new RingBuffer<uint8_t>(rbs);
1405 if (!write_to(_from_ui, index, protocol, size, body)) {
1406 error << "Error writing from UI to plugin" << endmsg;
1413 LV2Plugin::write_to_ui(uint32_t index,
1416 const uint8_t* body)
1418 if (!write_to(_to_ui, index, protocol, size, body)) {
1419 error << "Error writing from plugin to UI" << endmsg;
1426 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1428 switch (value.type()) {
1429 case Variant::NOTHING:
1431 case Variant::BEATS:
1432 // No atom type for this, just forge a double
1433 lv2_atom_forge_double(forge, value.get_beats().to_double());
1436 lv2_atom_forge_bool(forge, value.get_bool());
1438 case Variant::DOUBLE:
1439 lv2_atom_forge_double(forge, value.get_double());
1441 case Variant::FLOAT:
1442 lv2_atom_forge_float(forge, value.get_float());
1445 lv2_atom_forge_int(forge, value.get_int());
1448 lv2_atom_forge_long(forge, value.get_long());
1451 lv2_atom_forge_path(
1452 forge, value.get_path().c_str(), value.get_path().size());
1454 case Variant::STRING:
1455 lv2_atom_forge_string(
1456 forge, value.get_string().c_str(), value.get_string().size());
1460 forge, value.get_uri().c_str(), value.get_uri().size());
1465 /** Get a variant type from a URI, return false iff no match found. */
1467 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1469 if (uri == LV2_ATOM__Bool) {
1470 type = Variant::BOOL;
1471 } else if (uri == LV2_ATOM__Double) {
1472 type = Variant::DOUBLE;
1473 } else if (uri == LV2_ATOM__Float) {
1474 type = Variant::FLOAT;
1475 } else if (uri == LV2_ATOM__Int) {
1476 type = Variant::INT;
1477 } else if (uri == LV2_ATOM__Long) {
1478 type = Variant::LONG;
1479 } else if (uri == LV2_ATOM__Path) {
1480 type = Variant::PATH;
1481 } else if (uri == LV2_ATOM__String) {
1482 type = Variant::STRING;
1483 } else if (uri == LV2_ATOM__URI) {
1484 type = Variant::URI;
1492 LV2Plugin::set_property(uint32_t key, const Variant& value)
1494 if (_patch_port_in_index == (uint32_t)-1) {
1495 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1497 } else if (value.type() == Variant::NOTHING) {
1498 error << "LV2: set_property called with void value" << endmsg;
1502 // Set up forge to write to temporary buffer on the stack
1503 LV2_Atom_Forge* forge = &_impl->ui_forge;
1504 LV2_Atom_Forge_Frame frame;
1505 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1507 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1509 // Serialize patch:Set message to set property
1510 #ifdef HAVE_LV2_1_10_0
1511 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1512 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1513 lv2_atom_forge_urid(forge, key);
1514 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1516 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1517 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1518 lv2_atom_forge_urid(forge, key);
1519 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1522 forge_variant(forge, value);
1524 // Write message to UI=>Plugin ring
1525 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1526 write_from_ui(_patch_port_in_index,
1527 _uri_map.urids.atom_eventTransfer,
1528 lv2_atom_total_size(atom),
1529 (const uint8_t*)atom);
1532 const ParameterDescriptor&
1533 LV2Plugin::get_property_descriptor(uint32_t id) const
1535 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1536 if (p != _property_descriptors.end()) {
1539 return Plugin::get_property_descriptor(id);
1543 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1545 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1546 desc.unit = ParameterDescriptor::MIDI_NOTE;
1547 } else if (lilv_nodes_contains(units, _world.units_db)) {
1548 desc.unit = ParameterDescriptor::DB;
1549 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1550 desc.unit = ParameterDescriptor::HZ;
1552 if (lilv_nodes_size(units) > 0) {
1553 const LilvNode* unit = lilv_nodes_get_first(units);
1554 LilvNode* render = get_value(lworld, unit, _world.units_render);
1556 desc.print_fmt = lilv_node_as_string(render);
1557 lilv_node_free(render);
1563 load_parameter_descriptor(LV2World& world,
1564 ParameterDescriptor& desc,
1565 Variant::Type datatype,
1566 const LilvNode* subject)
1568 LilvWorld* lworld = _world.world;
1569 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1570 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1571 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1572 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1573 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1575 desc.label = lilv_node_as_string(label);
1577 if (def && lilv_node_is_float(def)) {
1578 desc.normal = lilv_node_as_float(def);
1580 if (minimum && lilv_node_is_float(minimum)) {
1581 desc.lower = lilv_node_as_float(minimum);
1583 if (maximum && lilv_node_is_float(maximum)) {
1584 desc.upper = lilv_node_as_float(maximum);
1586 load_parameter_descriptor_units(lworld, desc, units);
1587 desc.datatype = datatype;
1588 desc.toggled |= datatype == Variant::BOOL;
1589 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1590 desc.update_steps();
1592 lilv_nodes_free(units);
1593 lilv_node_free(label);
1594 lilv_node_free(def);
1595 lilv_node_free(minimum);
1596 lilv_node_free(maximum);
1600 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1602 LilvWorld* lworld = _world.world;
1603 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1604 LilvNodes* properties = lilv_world_find_nodes(
1605 lworld, subject, _world.patch_writable, NULL);
1606 LILV_FOREACH(nodes, p, properties) {
1607 // Get label and range
1608 const LilvNode* prop = lilv_nodes_get(properties, p);
1609 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1611 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1612 lilv_node_as_uri(prop)) << endmsg;
1616 // Convert range to variant type (TODO: support for multiple range types)
1617 Variant::Type datatype;
1618 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1619 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1620 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1624 // Add description to result
1625 ParameterDescriptor desc;
1626 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1627 desc.datatype = datatype;
1628 load_parameter_descriptor(_world, desc, datatype, prop);
1629 descs.insert(std::make_pair(desc.key, desc));
1631 lilv_node_free(range);
1633 lilv_nodes_free(properties);
1637 LV2Plugin::announce_property_values()
1639 if (_patch_port_in_index == (uint32_t)-1) {
1643 // Set up forge to write to temporary buffer on the stack
1644 LV2_Atom_Forge* forge = &_impl->ui_forge;
1645 LV2_Atom_Forge_Frame frame;
1646 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1648 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1650 // Serialize patch:Get message with no subject (implicitly plugin instance)
1651 #ifdef HAVE_LV2_1_10_0
1652 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1654 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1657 // Write message to UI=>Plugin ring
1658 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1659 write_from_ui(_patch_port_in_index,
1660 _uri_map.urids.atom_eventTransfer,
1661 lv2_atom_total_size(atom),
1662 (const uint8_t*)atom);
1666 LV2Plugin::enable_ui_emission()
1669 /* see note in LV2Plugin::write_from_ui() */
1670 uint32_t bufsiz = 32768;
1671 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1672 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1674 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1675 rbs = max((size_t) bufsiz * 8, rbs);
1676 _to_ui = new RingBuffer<uint8_t>(rbs);
1681 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1687 uint32_t read_space = _to_ui->read_space();
1688 while (read_space > sizeof(UIMessage)) {
1690 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1691 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1694 vector<uint8_t> body(msg.size);
1695 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1696 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1700 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1702 read_space -= sizeof(msg) + msg.size;
1707 LV2Plugin::work(uint32_t size, const void* data)
1709 return _impl->work_iface->work(
1710 _impl->instance->lv2_handle, work_respond, this, size, data);
1714 LV2Plugin::work_response(uint32_t size, const void* data)
1716 return _impl->work_iface->work_response(
1717 _impl->instance->lv2_handle, size, data);
1721 LV2Plugin::set_insert_id(PBD::ID id)
1723 if (_insert_id == "0") {
1725 } else if (_insert_id != id) {
1726 lilv_state_free(_impl->state);
1727 _impl->state = NULL;
1733 LV2Plugin::set_state_dir (const std::string& d)
1735 _plugin_state_dir = d;
1739 LV2Plugin::set_state(const XMLNode& node, int version)
1742 const XMLProperty* prop;
1743 XMLNodeConstIterator iter;
1748 LocaleGuard lg(X_("C"));
1750 if (node.name() != state_node_name()) {
1751 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1755 #ifndef NO_PLUGIN_STATE
1757 if (version < 3000) {
1758 nodes = node.children("port");
1760 nodes = node.children("Port");
1763 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1767 if ((prop = child->property("symbol")) != 0) {
1768 sym = prop->value().c_str();
1770 warning << _("LV2: port has no symbol, ignored") << endmsg;
1774 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1776 if (i != _port_indices.end()) {
1777 port_id = i->second;
1779 warning << _("LV2: port has unknown index, ignored") << endmsg;
1783 if ((prop = child->property("value")) != 0) {
1784 value = prop->value().c_str();
1786 warning << _("LV2: port has no value, ignored") << endmsg;
1790 set_parameter(port_id, atof(value));
1793 if ((prop = node.property("template-dir")) != 0) {
1794 set_state_dir (prop->value ());
1798 if ((prop = node.property("state-dir")) != 0) {
1799 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1800 error << string_compose(
1801 "LV2: failed to parse state version from \"%1\"",
1802 prop->value()) << endmsg;
1805 std::string state_file = Glib::build_filename(
1807 Glib::build_filename(prop->value(), "state.ttl"));
1809 LilvState* state = lilv_state_new_from_file(
1810 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1812 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1813 lilv_state_free(_impl->state);
1814 _impl->state = state;
1817 if (!_plugin_state_dir.empty ()) {
1818 // force save with session, next time (increment counter)
1819 lilv_state_free (_impl->state);
1820 _impl->state = NULL;
1824 latency_compute_run();
1827 return Plugin::set_state(node, version);
1831 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1833 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1835 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1840 LilvNodes* portunits;
1841 LilvNode *def, *min, *max;
1842 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1843 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1845 // TODO: Once we can rely on lilv 0.18.0 being present,
1846 // load_parameter_descriptor() can be used for ports as well
1847 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1848 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1849 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1850 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1851 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1852 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1853 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1854 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1855 load_parameter_descriptor_units(_world.world, desc, portunits);
1857 if (desc.sr_dependent) {
1858 desc.lower *= _session.frame_rate ();
1859 desc.upper *= _session.frame_rate ();
1862 desc.min_unbound = false; // TODO: LV2 extension required
1863 desc.max_unbound = false; // TODO: LV2 extension required
1865 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1866 desc.scale_points = get_scale_points(which);
1868 desc.update_steps();
1870 lilv_node_free(def);
1871 lilv_node_free(min);
1872 lilv_node_free(max);
1873 lilv_nodes_free(portunits);
1879 LV2Plugin::describe_parameter(Evoral::Parameter which)
1881 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1883 if (lilv_port_has_property(_impl->plugin,
1884 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1885 return X_("hidden");
1888 if (lilv_port_has_property(_impl->plugin,
1889 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1890 return X_("hidden");
1893 if (lilv_port_has_property(_impl->plugin,
1894 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1895 return X_("latency");
1898 LilvNode* name = lilv_port_get_name(_impl->plugin,
1899 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1900 string ret(lilv_node_as_string(name));
1901 lilv_node_free(name);
1909 LV2Plugin::signal_latency() const
1911 if (_latency_control_port) {
1912 return (framecnt_t)floor(*_latency_control_port);
1918 set<Evoral::Parameter>
1919 LV2Plugin::automatable() const
1921 set<Evoral::Parameter> ret;
1923 for (uint32_t i = 0; i < parameter_count(); ++i) {
1924 if (parameter_is_input(i) && parameter_is_control(i)) {
1925 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1929 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1930 p != _property_descriptors.end();
1932 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1938 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
1940 if ((_port_flags[i] & PORT_CTRLED)) {
1941 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
1945 LV2Plugin::AutomationCtrlPtr
1946 LV2Plugin::get_automation_control (uint32_t i)
1948 if (_ctrl_map.find (i) == _ctrl_map.end()) {
1949 return AutomationCtrlPtr ();
1951 return _ctrl_map[i];
1955 LV2Plugin::activate()
1957 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1959 if (!_was_activated) {
1960 lilv_instance_activate(_impl->instance);
1961 _was_activated = true;
1966 LV2Plugin::deactivate()
1968 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1970 if (_was_activated) {
1971 lilv_instance_deactivate(_impl->instance);
1972 _was_activated = false;
1977 LV2Plugin::cleanup()
1979 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1982 lilv_instance_free(_impl->instance);
1983 _impl->instance = NULL;
1987 LV2Plugin::allocate_atom_event_buffers()
1989 /* reserve local scratch buffers for ATOM event-queues */
1990 const LilvPlugin* p = _impl->plugin;
1992 /* count non-MIDI atom event-ports
1993 * TODO: nicely ask drobilla to make a lilv_ call for that
1995 int count_atom_out = 0;
1996 int count_atom_in = 0;
1997 int minimumSize = 32768; // TODO use a per-port minimum-size
1998 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1999 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2000 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2001 LilvNodes* buffer_types = lilv_port_get_value(
2002 p, port, _world.atom_bufferType);
2003 LilvNodes* atom_supports = lilv_port_get_value(
2004 p, port, _world.atom_supports);
2006 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
2007 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
2008 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2011 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2014 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2015 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2016 if (min_size && lilv_node_is_int(min_size)) {
2017 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2019 lilv_nodes_free(min_size_v);
2021 lilv_nodes_free(buffer_types);
2022 lilv_nodes_free(atom_supports);
2026 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2027 name(), count_atom_in, count_atom_out));
2029 const int total_atom_buffers = (count_atom_in + count_atom_out);
2030 if (_atom_ev_buffers || total_atom_buffers == 0) {
2034 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
2035 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2036 for (int i = 0; i < total_atom_buffers; ++i ) {
2037 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2038 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2040 _atom_ev_buffers[total_atom_buffers] = 0;
2044 /** Write an ardour position/time/tempo/meter as an LV2 event.
2045 * @return true on success.
2048 write_position(LV2_Atom_Forge* forge,
2050 const TempoMetric& t,
2051 Timecode::BBT_Time& bbt,
2053 framepos_t position,
2056 const URIMap::URIDs& urids = URIMap::instance().urids;
2058 uint8_t pos_buf[256];
2059 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2060 LV2_Atom_Forge_Frame frame;
2061 #ifdef HAVE_LV2_1_10_0
2062 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2063 lv2_atom_forge_key(forge, urids.time_frame);
2064 lv2_atom_forge_long(forge, position);
2065 lv2_atom_forge_key(forge, urids.time_speed);
2066 lv2_atom_forge_float(forge, speed);
2067 lv2_atom_forge_key(forge, urids.time_barBeat);
2068 lv2_atom_forge_float(forge, bbt.beats - 1 +
2069 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2070 lv2_atom_forge_key(forge, urids.time_bar);
2071 lv2_atom_forge_long(forge, bbt.bars - 1);
2072 lv2_atom_forge_key(forge, urids.time_beatUnit);
2073 lv2_atom_forge_int(forge, t.meter().note_divisor());
2074 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2075 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2076 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2077 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2079 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2080 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2081 lv2_atom_forge_long(forge, position);
2082 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2083 lv2_atom_forge_float(forge, speed);
2084 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2085 lv2_atom_forge_float(forge, bbt.beats - 1 +
2086 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2087 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2088 lv2_atom_forge_long(forge, bbt.bars - 1);
2089 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2090 lv2_atom_forge_int(forge, t.meter().note_divisor());
2091 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2092 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2093 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2094 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2097 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2098 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2099 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2100 (const uint8_t*)(atom + 1));
2104 LV2Plugin::connect_and_run(BufferSet& bufs,
2105 ChanMapping in_map, ChanMapping out_map,
2106 pframes_t nframes, framecnt_t offset)
2108 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2109 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2111 cycles_t then = get_cycles();
2113 TempoMap& tmap = _session.tempo_map();
2114 Metrics::const_iterator metric_i = tmap.metrics_end();
2115 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2117 if (_freewheel_control_port) {
2118 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2121 if (_bpm_control_port) {
2122 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2126 if (_can_write_automation && _session.transport_frame() != _next_cycle_start) {
2127 // add guard-points after locating
2128 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2129 i->second->guard = true;
2134 ChanCount bufs_count;
2135 bufs_count.set(DataType::AUDIO, 1);
2136 bufs_count.set(DataType::MIDI, 1);
2137 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2138 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2139 uint32_t const num_ports = parameter_count();
2140 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2142 uint32_t audio_in_index = 0;
2143 uint32_t audio_out_index = 0;
2144 uint32_t midi_in_index = 0;
2145 uint32_t midi_out_index = 0;
2146 uint32_t atom_port_index = 0;
2147 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2149 uint32_t index = nil_index;
2150 PortFlags flags = _port_flags[port_index];
2152 if (flags & PORT_AUDIO) {
2153 if (flags & PORT_INPUT) {
2154 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2156 ? bufs.get_audio(index).data(offset)
2157 : silent_bufs.get_audio(0).data(offset);
2159 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2161 ? bufs.get_audio(index).data(offset)
2162 : scratch_bufs.get_audio(0).data(offset);
2164 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2165 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2166 be necessary, but the mapping is illegal in some cases. Ideally
2167 that should be fixed, but this is easier...
2169 if (flags & PORT_MIDI) {
2170 if (flags & PORT_INPUT) {
2171 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2173 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2175 if (valid && bufs.count().n_midi() > index) {
2176 /* Note, ensure_lv2_bufsize() is not RT safe!
2177 * However free()/alloc() is only called if a
2178 * plugin requires a rsz:minimumSize buffersize
2179 * and the existing buffer if smaller.
2181 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2182 _ev_buffers[port_index] = bufs.get_lv2_midi(
2183 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2185 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2186 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2187 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2191 if (valid && (flags & PORT_INPUT)) {
2192 Timecode::BBT_Time bbt;
2193 if ((flags & PORT_POSITION)) {
2194 if (_session.transport_frame() != _next_cycle_start ||
2195 _session.transport_speed() != _next_cycle_speed) {
2196 // Transport has changed, write position at cycle start
2197 tmap.bbt_time(_session.transport_frame(), bbt);
2198 write_position(&_impl->forge, _ev_buffers[port_index],
2199 tmetric, bbt, _session.transport_speed(),
2200 _session.transport_frame(), 0);
2204 // Get MIDI iterator range (empty range if no MIDI)
2205 MidiBuffer::iterator m = (index != nil_index)
2206 ? bufs.get_midi(index).begin()
2207 : silent_bufs.get_midi(0).end();
2208 MidiBuffer::iterator m_end = (index != nil_index)
2209 ? bufs.get_midi(index).end()
2212 // Now merge MIDI and any transport events into the buffer
2213 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2214 const framepos_t tend = _session.transport_frame() + nframes;
2216 while (m != m_end || (metric_i != tmap.metrics_end() &&
2217 (*metric_i)->frame() < tend)) {
2218 MetricSection* metric = (metric_i != tmap.metrics_end())
2220 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2221 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2222 if (ev.time() < nframes) {
2223 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2224 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2228 tmetric.set_metric(metric);
2229 bbt = metric->start();
2230 write_position(&_impl->forge, _ev_buffers[port_index],
2231 tmetric, bbt, _session.transport_speed(),
2233 metric->frame() - _session.transport_frame());
2237 } else if (!valid) {
2238 // Nothing we understand or care about, connect to scratch
2239 // see note for midi-buffer size above
2240 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2241 0, _port_minimumSize[port_index]);
2242 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2243 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2246 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2248 continue; // Control port, leave buffer alone
2250 lilv_instance_connect_port(_impl->instance, port_index, buf);
2253 // Read messages from UI and push into appropriate buffers
2255 uint32_t read_space = _from_ui->read_space();
2256 while (read_space > sizeof(UIMessage)) {
2258 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2259 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2262 vector<uint8_t> body(msg.size);
2263 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2264 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2267 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2268 LV2_Evbuf* buf = _ev_buffers[msg.index];
2269 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2270 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2271 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2272 (const uint8_t*)(atom + 1))) {
2273 error << "Failed to write data to LV2 event buffer\n";
2276 error << "Received unknown message type from UI" << endmsg;
2278 read_space -= sizeof(UIMessage) + msg.size;
2285 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2286 PortFlags flags = _port_flags[port_index];
2289 /* TODO ask drobilla about comment
2290 * "Make Ardour event buffers generic so plugins can communicate"
2291 * in libs/ardour/buffer_set.cc:310
2293 * ideally the user could choose which of the following two modes
2294 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2296 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2297 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2298 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2299 * for quite a while at least ;)
2301 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2302 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2303 const uint32_t buf_index = out_map.get(
2304 DataType::MIDI, midi_out_index++, &valid);
2306 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2309 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2310 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2311 const uint32_t buf_index = out_map.get(
2312 DataType::MIDI, midi_out_index++, &valid);
2314 bufs.flush_lv2_midi(true, buf_index);
2318 // Write messages to UI
2319 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2320 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2321 LV2_Evbuf* buf = _ev_buffers[port_index];
2322 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2323 lv2_evbuf_is_valid(i);
2324 i = lv2_evbuf_next(i)) {
2325 uint32_t frames, subframes, type, size;
2327 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2330 // Intercept Automation Write Events
2331 if ((flags & PORT_AUTOCTRL)) {
2332 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2333 if (atom->type == _uri_map.urids.atom_Blank ||
2334 atom->type == _uri_map.urids.atom_Object) {
2335 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2336 if (obj->body.otype == _uri_map.urids.auto_event) {
2337 // only if transport_rolling ??
2338 const LV2_Atom* parameter = NULL;
2339 const LV2_Atom* value = NULL;
2340 lv2_atom_object_get(obj,
2341 _uri_map.urids.auto_parameter, ¶meter,
2342 _uri_map.urids.auto_value, &value,
2344 if (parameter && value) {
2345 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2346 const float v = ((const LV2_Atom_Float*)value)->body;
2347 // -> add automation event..
2348 AutomationCtrlPtr c = get_automation_control (p);
2349 if (c && c->ac->automation_state() == Touch) {
2352 c->ac->list()->add (_session.transport_frame() + frames, v, true, true);
2354 c->ac->set_double (v, _session.transport_frame() + frames, true);
2359 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2360 // TODO optional arguments, for now we assume the plugin
2361 // writes automation for its own inputs
2362 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2363 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2364 i->second->ac->set_automation_state (Touch);
2367 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2368 // set [touched] parameters to "play" ??
2370 else if (obj->body.otype == _uri_map.urids.auto_start) {
2371 const LV2_Atom* parameter = NULL;
2372 lv2_atom_object_get(obj,
2373 _uri_map.urids.auto_parameter, ¶meter,
2376 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2377 AutomationCtrlPtr c = get_automation_control (p);
2379 c->ac->start_touch (_session.transport_frame());
2384 else if (obj->body.otype == _uri_map.urids.auto_end) {
2385 const LV2_Atom* parameter = NULL;
2386 lv2_atom_object_get(obj,
2387 _uri_map.urids.auto_parameter, ¶meter,
2390 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2391 AutomationCtrlPtr c = get_automation_control (p);
2393 c->ac->stop_touch (true, _session.transport_frame());
2401 // Intercept patch change messages to emit PropertyChanged signal
2402 if ((flags & PORT_PATCHMSG)) {
2403 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2404 if (atom->type == _uri_map.urids.atom_Blank ||
2405 atom->type == _uri_map.urids.atom_Object) {
2406 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2407 if (obj->body.otype == _uri_map.urids.patch_Set) {
2408 const LV2_Atom* property = NULL;
2409 const LV2_Atom* value = NULL;
2410 lv2_atom_object_get(obj,
2411 _uri_map.urids.patch_property, &property,
2412 _uri_map.urids.patch_value, &value,
2415 if (!property || !value ||
2416 property->type != _uri_map.urids.atom_URID ||
2417 value->type != _uri_map.urids.atom_Path) {
2418 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2422 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2423 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2425 // Emit PropertyChanged signal for UI
2426 // TODO: This should emit the control's Changed signal
2427 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2432 if (!_to_ui) continue;
2433 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2434 size + sizeof(LV2_Atom),
2435 data - sizeof(LV2_Atom));
2440 cycles_t now = get_cycles();
2441 set_cycles((uint32_t)(now - then));
2443 // Update expected transport information for next cycle so we can detect changes
2444 _next_cycle_speed = _session.transport_speed();
2445 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2451 LV2Plugin::parameter_is_control(uint32_t param) const
2453 assert(param < _port_flags.size());
2454 return _port_flags[param] & PORT_CONTROL;
2458 LV2Plugin::parameter_is_audio(uint32_t param) const
2460 assert(param < _port_flags.size());
2461 return _port_flags[param] & PORT_AUDIO;
2465 LV2Plugin::parameter_is_event(uint32_t param) const
2467 assert(param < _port_flags.size());
2468 return _port_flags[param] & PORT_EVENT;
2472 LV2Plugin::parameter_is_output(uint32_t param) const
2474 assert(param < _port_flags.size());
2475 return _port_flags[param] & PORT_OUTPUT;
2479 LV2Plugin::parameter_is_input(uint32_t param) const
2481 assert(param < _port_flags.size());
2482 return _port_flags[param] & PORT_INPUT;
2486 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2489 if (param < parameter_count()) {
2490 snprintf(buf, len, "%.3f", get_parameter(param));
2497 boost::shared_ptr<ScalePoints>
2498 LV2Plugin::get_scale_points(uint32_t port_index) const
2500 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2501 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2503 boost::shared_ptr<ScalePoints> ret;
2508 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2510 LILV_FOREACH(scale_points, i, points) {
2511 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2512 const LilvNode* label = lilv_scale_point_get_label(p);
2513 const LilvNode* value = lilv_scale_point_get_value(p);
2514 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2515 ret->insert(make_pair(lilv_node_as_string(label),
2516 lilv_node_as_float(value)));
2520 lilv_scale_points_free(points);
2525 LV2Plugin::run(pframes_t nframes)
2527 uint32_t const N = parameter_count();
2528 for (uint32_t i = 0; i < N; ++i) {
2529 if (parameter_is_control(i) && parameter_is_input(i)) {
2530 _control_data[i] = _shadow_data[i];
2534 lilv_instance_run(_impl->instance, nframes);
2536 if (_impl->work_iface) {
2537 _worker->emit_responses();
2538 if (_impl->work_iface->end_run) {
2539 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2545 LV2Plugin::latency_compute_run()
2547 if (!_latency_control_port) {
2551 // Run the plugin so that it can set its latency parameter
2553 bool was_activated = _was_activated;
2556 uint32_t port_index = 0;
2557 uint32_t in_index = 0;
2558 uint32_t out_index = 0;
2560 // this is done in the main thread. non realtime.
2561 const framecnt_t bufsize = _engine.samples_per_cycle();
2562 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2564 memset(buffer, 0, sizeof(float) * bufsize);
2566 // FIXME: Ensure plugins can handle in-place processing
2570 while (port_index < parameter_count()) {
2571 if (parameter_is_audio(port_index)) {
2572 if (parameter_is_input(port_index)) {
2573 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2575 } else if (parameter_is_output(port_index)) {
2576 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2585 if (was_activated) {
2592 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2594 const LilvPort* port = NULL;
2595 LilvNode* designation = lilv_new_uri(_world.world, uri);
2596 port = lilv_plugin_get_port_by_designation(
2597 plugin, _world.lv2_InputPort, designation);
2598 lilv_node_free(designation);
2600 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2605 static bool lv2_filter (const string& str, void* /*arg*/)
2607 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2609 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2613 LV2World::LV2World()
2614 : world(lilv_world_new())
2615 , _bundle_checked(false)
2617 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2618 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2619 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2620 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2621 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2622 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2623 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2624 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2625 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2626 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2627 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2628 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2629 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2630 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2631 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2632 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2633 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2634 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2635 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2636 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2637 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2638 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2639 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2640 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2641 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2642 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2643 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2644 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2645 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2646 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2647 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2648 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2649 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2650 units_render = lilv_new_uri(world, LV2_UNITS__render);
2651 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2652 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2653 units_db = lilv_new_uri(world, LV2_UNITS__db);
2654 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2655 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2657 lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2658 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
2659 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
2660 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
2662 #ifdef HAVE_LV2_1_2_0
2663 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2664 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2665 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2670 LV2World::~LV2World()
2675 #ifdef HAVE_LV2_1_2_0
2676 lilv_node_free(bufz_nominalBlockLength);
2677 lilv_node_free(bufz_fixedBlockLength);
2678 lilv_node_free(bufz_powerOf2BlockLength);
2681 lilv_node_free(lv2_noSampleAccurateCtrl);
2682 lilv_node_free(auto_can_write_automatation);
2683 lilv_node_free(auto_automation_control);
2684 lilv_node_free(auto_automation_controlled);
2686 lilv_node_free(patch_Message);
2687 lilv_node_free(patch_writable);
2688 lilv_node_free(units_hz);
2689 lilv_node_free(units_midiNote);
2690 lilv_node_free(units_db);
2691 lilv_node_free(units_unit);
2692 lilv_node_free(units_render);
2693 lilv_node_free(ui_externalkx);
2694 lilv_node_free(ui_external);
2695 lilv_node_free(ui_GtkUI);
2696 lilv_node_free(time_Position);
2697 lilv_node_free(rsz_minimumSize);
2698 lilv_node_free(rdfs_comment);
2699 lilv_node_free(rdfs_label);
2700 lilv_node_free(rdfs_range);
2701 lilv_node_free(midi_MidiEvent);
2702 lilv_node_free(lv2_enumeration);
2703 lilv_node_free(lv2_freewheeling);
2704 lilv_node_free(lv2_toggled);
2705 lilv_node_free(lv2_sampleRate);
2706 lilv_node_free(lv2_reportsLatency);
2707 lilv_node_free(lv2_integer);
2708 lilv_node_free(lv2_inPlaceBroken);
2709 lilv_node_free(lv2_OutputPort);
2710 lilv_node_free(lv2_InputPort);
2711 lilv_node_free(lv2_ControlPort);
2712 lilv_node_free(lv2_AudioPort);
2713 lilv_node_free(ext_notOnGUI);
2714 lilv_node_free(ext_logarithmic);
2715 lilv_node_free(ev_EventPort);
2716 lilv_node_free(atom_supports);
2717 lilv_node_free(atom_eventTransfer);
2718 lilv_node_free(atom_bufferType);
2719 lilv_node_free(atom_Sequence);
2720 lilv_node_free(atom_Chunk);
2721 lilv_node_free(atom_AtomPort);
2722 lilv_world_free(world);
2727 LV2World::load_bundled_plugins(bool verbose)
2729 if (!_bundle_checked) {
2731 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2734 vector<string> plugin_objects;
2735 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2736 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2737 #ifdef PLATFORM_WINDOWS
2738 string uri = "file:///" + *x + "/";
2740 string uri = "file://" + *x + "/";
2742 LilvNode *node = lilv_new_uri(world, uri.c_str());
2743 lilv_world_load_bundle(world, node);
2744 lilv_node_free(node);
2747 lilv_world_load_all(world);
2748 _bundle_checked = true;
2752 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2755 _plugin_uri = strdup(plugin_uri);
2758 LV2PluginInfo::~LV2PluginInfo()
2765 LV2PluginInfo::load(Session& session)
2769 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2770 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2771 if (!uri) { throw failed_constructor(); }
2772 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2773 if (!lp) { throw failed_constructor(); }
2774 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2775 lilv_node_free(uri);
2776 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2778 } catch (failed_constructor& err) {
2779 return PluginPtr((Plugin*)0);
2785 std::vector<Plugin::PresetRecord>
2786 LV2PluginInfo::get_presets (bool /*user_only*/) const
2788 std::vector<Plugin::PresetRecord> p;
2789 #ifndef NO_PLUGIN_STATE
2790 const LilvPlugin* lp = NULL;
2793 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2794 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2795 if (!uri) { throw failed_constructor(); }
2796 lp = lilv_plugins_get_by_uri(plugins, uri);
2797 if (!lp) { throw failed_constructor(); }
2798 lilv_node_free(uri);
2799 } catch (failed_constructor& err) {
2803 // see LV2Plugin::find_presets
2804 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
2805 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
2806 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
2808 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
2809 LILV_FOREACH(nodes, i, presets) {
2810 const LilvNode* preset = lilv_nodes_get(presets, i);
2811 lilv_world_load_resource(_world.world, preset);
2812 LilvNode* name = get_value(_world.world, preset, rdfs_label);
2813 bool userpreset = true; // TODO
2815 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
2816 lilv_node_free(name);
2819 lilv_nodes_free(presets);
2820 lilv_node_free(rdfs_label);
2821 lilv_node_free(pset_Preset);
2822 lilv_node_free(lv2_appliesTo);
2828 LV2PluginInfo::in_category (const std::string &c) const
2830 // TODO use untranslated lilv_plugin_get_class()
2831 // match gtk2_ardour/plugin_selector.cc
2832 if (category == c) {
2839 LV2PluginInfo::is_instrument () const
2841 if (category == "Instrument") {
2845 /* until we make sure that category remains untranslated in the lv2.ttl spec
2846 * and until most instruments also classify themselves as such, there's a 2nd check:
2848 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2856 LV2PluginInfo::discover()
2859 world.load_bundled_plugins();
2860 _world.load_bundled_plugins(true);
2862 PluginInfoList* plugs = new PluginInfoList;
2863 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2865 LILV_FOREACH(plugins, i, plugins) {
2866 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2867 const LilvNode* pun = lilv_plugin_get_uri(p);
2869 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2871 LilvNode* name = lilv_plugin_get_name(p);
2872 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2873 warning << "Ignoring invalid LV2 plugin "
2874 << lilv_node_as_string(lilv_plugin_get_uri(p))
2879 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2880 warning << string_compose(
2881 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2882 lilv_node_as_string(name)) << endmsg;
2883 lilv_node_free(name);
2887 #ifdef HAVE_LV2_1_2_0
2888 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2889 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2890 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2892 warning << string_compose(
2893 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2894 lilv_node_as_string(name)) << endmsg;
2895 lilv_nodes_free(required_features);
2896 lilv_node_free(name);
2899 lilv_nodes_free(required_features);
2904 info->name = string(lilv_node_as_string(name));
2905 lilv_node_free(name);
2906 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2908 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2909 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2910 info->category = lilv_node_as_string(label);
2912 LilvNode* author_name = lilv_plugin_get_author_name(p);
2913 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2914 lilv_node_free(author_name);
2916 info->path = "/NOPATH"; // Meaningless for LV2
2918 /* count atom-event-ports that feature
2919 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2921 * TODO: nicely ask drobilla to make a lilv_ call for that
2923 int count_midi_out = 0;
2924 int count_midi_in = 0;
2925 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2926 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2927 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2928 LilvNodes* buffer_types = lilv_port_get_value(
2929 p, port, world.atom_bufferType);
2930 LilvNodes* atom_supports = lilv_port_get_value(
2931 p, port, world.atom_supports);
2933 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2934 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2935 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2938 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2942 lilv_nodes_free(buffer_types);
2943 lilv_nodes_free(atom_supports);
2947 info->n_inputs.set_audio(
2948 lilv_plugin_get_num_ports_of_class(
2949 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2950 info->n_inputs.set_midi(
2951 lilv_plugin_get_num_ports_of_class(
2952 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2955 info->n_outputs.set_audio(
2956 lilv_plugin_get_num_ports_of_class(
2957 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2958 info->n_outputs.set_midi(
2959 lilv_plugin_get_num_ports_of_class(
2960 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2963 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2964 info->index = 0; // Meaningless for LV2
2966 plugs->push_back(info);