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 LilvNode* lv2_noSampleAccurateCtrl;
159 #ifdef HAVE_LV2_1_2_0
160 LilvNode* bufz_powerOf2BlockLength;
161 LilvNode* bufz_fixedBlockLength;
162 LilvNode* bufz_nominalBlockLength;
166 bool _bundle_checked;
169 static LV2World _world;
171 /* worker extension */
173 /** Called by the plugin to schedule non-RT work. */
174 static LV2_Worker_Status
175 work_schedule(LV2_Worker_Schedule_Handle handle,
179 LV2Plugin* plugin = (LV2Plugin*)handle;
180 if (plugin->session().engine().freewheeling()) {
181 // Freewheeling, do the work immediately in this (audio) thread
182 return (LV2_Worker_Status)plugin->work(size, data);
184 // Enqueue message for the worker thread
185 return plugin->worker()->schedule(size, data) ?
186 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
190 /** Called by the plugin to respond to non-RT work. */
191 static LV2_Worker_Status
192 work_respond(LV2_Worker_Respond_Handle handle,
196 LV2Plugin* plugin = (LV2Plugin*)handle;
197 if (plugin->session().engine().freewheeling()) {
198 // Freewheeling, respond immediately in this (audio) thread
199 return (LV2_Worker_Status)plugin->work_response(size, data);
201 // Enqueue response for the worker
202 return plugin->worker()->respond(size, data) ?
203 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
210 log_vprintf(LV2_Log_Handle /*handle*/,
216 const int ret = g_vasprintf(&str, fmt, args);
217 if (type == URIMap::instance().urids.log_Error) {
218 error << str << endmsg;
219 } else if (type == URIMap::instance().urids.log_Warning) {
220 warning << str << endmsg;
221 } else if (type == URIMap::instance().urids.log_Note) {
222 info << str << endmsg;
224 // TODO: Toggleable log:Trace message support
229 log_printf(LV2_Log_Handle handle,
231 const char* fmt, ...)
235 const int ret = log_vprintf(handle, type, fmt, args);
240 struct LV2Plugin::Impl {
241 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
243 #ifdef HAVE_LV2_1_2_0
248 #ifdef HAVE_LV2_1_2_0
253 /** Find the LV2 input port with the given designation.
254 * If found, bufptrs[port_index] will be set to bufptr.
256 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
258 const LilvPlugin* plugin;
260 const LilvNode* ui_type;
263 LilvInstance* instance;
264 const LV2_Worker_Interface* work_iface;
265 #ifdef HAVE_LV2_1_2_0
266 const LV2_Options_Interface* opts_iface;
269 LV2_Atom_Forge forge;
270 LV2_Atom_Forge ui_forge;
271 int32_t block_length;
272 #ifdef HAVE_LV2_1_2_0
273 LV2_Options_Option* options;
277 LV2Plugin::LV2Plugin (AudioEngine& engine,
279 const void* c_plugin,
281 : Plugin (engine, session)
287 , _patch_port_in_index((uint32_t)-1)
288 , _patch_port_out_index((uint32_t)-1)
289 , _uri_map(URIMap::instance())
290 , _no_sample_accurate_ctrl (false)
292 init(c_plugin, rate);
295 LV2Plugin::LV2Plugin (const LV2Plugin& other)
301 , _insert_id(other._insert_id)
302 , _patch_port_in_index((uint32_t)-1)
303 , _patch_port_out_index((uint32_t)-1)
304 , _uri_map(URIMap::instance())
305 , _no_sample_accurate_ctrl (false)
307 init(other._impl->plugin, other._sample_rate);
309 for (uint32_t i = 0; i < parameter_count(); ++i) {
310 _control_data[i] = other._shadow_data[i];
311 _shadow_data[i] = other._shadow_data[i];
316 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
318 DEBUG_TRACE(DEBUG::LV2, "init\n");
320 _impl->plugin = (const LilvPlugin*)c_plugin;
322 _impl->ui_type = NULL;
327 _atom_ev_buffers = 0;
329 _bpm_control_port = 0;
330 _freewheel_control_port = 0;
331 _latency_control_port = 0;
332 _next_cycle_start = std::numeric_limits<framepos_t>::max();
333 _next_cycle_speed = 1.0;
334 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
336 _was_activated = false;
337 _has_state_interface = false;
338 _impl->block_length = _session.get_block_size();
340 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
341 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
342 _make_path_feature.URI = LV2_STATE__makePath;
343 _log_feature.URI = LV2_LOG__log;
344 _work_schedule_feature.URI = LV2_WORKER__schedule;
345 _work_schedule_feature.data = NULL;
346 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
347 _def_state_feature.data = NULL;
349 const LilvPlugin* plugin = _impl->plugin;
351 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
352 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
353 _has_state_interface =
354 // What plugins should have (lv2:extensionData state:Interface)
355 lilv_plugin_has_extension_data(plugin, state_iface_uri)
356 // What some outdated/incorrect ones have
357 || lilv_plugin_has_feature(plugin, state_uri);
358 lilv_node_free(state_uri);
359 lilv_node_free(state_iface_uri);
361 _features = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
362 _features[0] = &_instance_access_feature;
363 _features[1] = &_data_access_feature;
364 _features[2] = &_make_path_feature;
365 _features[3] = _uri_map.uri_map_feature();
366 _features[4] = _uri_map.urid_map_feature();
367 _features[5] = _uri_map.urid_unmap_feature();
368 _features[6] = &_log_feature;
370 unsigned n_features = 7;
371 #ifdef HAVE_LV2_1_2_0
372 _features[n_features++] = &_def_state_feature;
375 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
376 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
378 #ifdef HAVE_LV2_1_2_0
379 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
380 static const int32_t _min_block_length = 1; // may happen during split-cycles
381 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
382 /* Consider updating max-block-size whenever the buffersize changes.
383 * It requires re-instantiating the plugin (which is a non-realtime operation),
384 * so it should be done lightly and only for plugins that require it.
386 * given that the block-size can change at any time (split-cycles) ardour currently
387 * does not support plugins that require bufz_fixedBlockLength.
389 LV2_Options_Option options[] = {
390 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
391 sizeof(int32_t), atom_Int, &_min_block_length },
392 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
393 sizeof(int32_t), atom_Int, &_max_block_length },
394 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
395 sizeof(int32_t), atom_Int, &_seq_size },
396 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
397 sizeof(int32_t), atom_Int, &_impl->block_length },
398 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
401 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
402 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
404 _options_feature.URI = LV2_OPTIONS__options;
405 _options_feature.data = _impl->options;
406 _features[n_features++] = &_options_feature;
409 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
410 sizeof(LV2_State_Make_Path));
411 make_path->handle = this;
412 make_path->path = &lv2_state_make_path;
413 _make_path_feature.data = make_path;
415 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
417 log->printf = &log_printf;
418 log->vprintf = &log_vprintf;
419 _log_feature.data = log;
421 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
422 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
423 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
424 sizeof(LV2_Worker_Schedule));
425 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
426 _worker = new Worker(this, buf_size);
427 schedule->handle = this;
428 schedule->schedule_work = work_schedule;
429 _work_schedule_feature.data = schedule;
430 _features[n_features++] = &_work_schedule_feature;
432 lilv_node_free(worker_schedule);
434 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
435 _impl->name = lilv_plugin_get_name(plugin);
436 _impl->author = lilv_plugin_get_author_name(plugin);
438 if (_impl->instance == 0) {
439 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
440 throw failed_constructor();
443 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
444 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
445 _data_access_feature.data = &_data_access_extension_data;
447 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
448 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
449 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
450 LV2_WORKER__interface);
452 lilv_node_free(worker_iface_uri);
455 #ifdef HAVE_LV2_1_2_0
456 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
457 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
458 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
459 LV2_OPTIONS__interface);
461 lilv_node_free(options_iface_uri);
464 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
465 error << string_compose(
466 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
467 lilv_node_as_string(_impl->name)) << endmsg;
468 lilv_node_free(_impl->name);
469 lilv_node_free(_impl->author);
470 throw failed_constructor();
473 #ifdef HAVE_LV2_1_2_0
474 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
475 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
476 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
478 error << string_compose(
479 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
480 lilv_node_as_string(_impl->name)) << endmsg;
481 lilv_node_free(_impl->name);
482 lilv_node_free(_impl->author);
483 lilv_nodes_free(required_features);
484 throw failed_constructor();
486 lilv_nodes_free(required_features);
488 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
489 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
490 _no_sample_accurate_ctrl = true;
492 lilv_nodes_free(optional_features);
495 #ifdef HAVE_LILV_0_16_0
496 // Load default state
497 LilvState* state = lilv_state_new_from_world(
498 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
499 if (state && _has_state_interface) {
500 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
502 lilv_state_free(state);
507 const uint32_t num_ports = this->num_ports();
508 for (uint32_t i = 0; i < num_ports; ++i) {
509 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
511 size_t minimumSize = 0;
513 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
514 flags |= PORT_OUTPUT;
515 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
518 error << string_compose(
519 "LV2: \"%1\" port %2 is neither input nor output",
520 lilv_node_as_string(_impl->name), i) << endmsg;
521 throw failed_constructor();
524 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
525 flags |= PORT_CONTROL;
526 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
528 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
530 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
531 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
532 LilvNodes* buffer_types = lilv_port_get_value(
533 _impl->plugin, port, _world.atom_bufferType);
534 LilvNodes* atom_supports = lilv_port_get_value(
535 _impl->plugin, port, _world.atom_supports);
537 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
538 flags |= PORT_SEQUENCE;
539 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
542 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
543 flags |= PORT_POSITION;
545 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
546 flags |= PORT_PATCHMSG;
547 if (flags & PORT_INPUT) {
548 _patch_port_in_index = i;
550 _patch_port_out_index = i;
554 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
555 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
556 if (min_size && lilv_node_is_int(min_size)) {
557 minimumSize = lilv_node_as_int(min_size);
559 lilv_nodes_free(min_size_v);
560 lilv_nodes_free(buffer_types);
561 lilv_nodes_free(atom_supports);
563 error << string_compose(
564 "LV2: \"%1\" port %2 has no known data type",
565 lilv_node_as_string(_impl->name), i) << endmsg;
566 throw failed_constructor();
569 _port_flags.push_back(flags);
570 _port_minimumSize.push_back(minimumSize);
573 _control_data = new float[num_ports];
574 _shadow_data = new float[num_ports];
575 _defaults = new float[num_ports];
576 _ev_buffers = new LV2_Evbuf*[num_ports];
577 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
579 const bool latent = lilv_plugin_has_latency(plugin);
580 const uint32_t latency_index = (latent)
581 ? lilv_plugin_get_latency_port_index(plugin)
584 // Build an array of pointers to special parameter buffers
585 void*** params = new void**[num_ports];
586 for (uint32_t i = 0; i < num_ports; ++i) {
589 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
590 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
592 for (uint32_t i = 0; i < num_ports; ++i) {
593 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
594 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
596 // Store index in map so we can look up index by symbol
597 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
599 // Get range and default value if applicable
600 if (parameter_is_control(i)) {
602 lilv_port_get_range(plugin, port, &def, NULL, NULL);
603 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
604 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
605 _defaults[i] *= _session.frame_rate ();
609 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
611 if (latent && i == latency_index) {
612 _latency_control_port = &_control_data[i];
613 *_latency_control_port = 0;
616 if (parameter_is_input(i)) {
617 _shadow_data[i] = default_value(i);
619 *params[i] = (void*)&_shadow_data[i];
629 LilvUIs* uis = lilv_plugin_get_uis(plugin);
630 if (lilv_uis_size(uis) > 0) {
632 // Look for embeddable UI
633 LILV_FOREACH(uis, u, uis) {
634 const LilvUI* this_ui = lilv_uis_get(uis, u);
635 const LilvNode* this_ui_type = NULL;
636 if (lilv_ui_is_supported(this_ui,
640 // TODO: Multiple UI support
642 _impl->ui_type = this_ui_type;
647 // Look for Gtk native UI
648 LILV_FOREACH(uis, i, uis) {
649 const LilvUI* ui = lilv_uis_get(uis, i);
650 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
652 _impl->ui_type = _world.ui_GtkUI;
658 // If Gtk UI is not available, try to find external UI
660 LILV_FOREACH(uis, i, uis) {
661 const LilvUI* ui = lilv_uis_get(uis, i);
662 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
664 _impl->ui_type = _world.ui_external;
667 if (lilv_ui_is_a(ui, _world.ui_external)) {
669 _impl->ui_type = _world.ui_external;
675 load_supported_properties(_property_descriptors);
676 allocate_atom_event_buffers();
677 latency_compute_run();
681 LV2Plugin::set_block_size (pframes_t nframes)
683 #ifdef HAVE_LV2_1_2_0
684 if (_impl->opts_iface) {
685 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
686 _impl->block_length = nframes;
687 LV2_Options_Option block_size_option = {
688 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
689 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
691 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
698 LV2Plugin::requires_fixed_sized_buffers () const
700 /* This controls if Ardour will split the plugin's run()
701 * on automation events in order to pass sample-accurate automation
702 * via standard control-ports.
704 * When returning true Ardour will *not* sub-divide the process-cycle.
705 * Automation events that happen between cycle-start and cycle-end will be
706 * ignored (ctrl values are interpolated to cycle-start).
707 * NB. Atom Sequences are still sample accurate.
709 * Note: This does not guarantee a fixed block-size.
710 * e.g The process cycle may be split when looping, also
711 * the period-size may change any time: see set_block_size()
713 return _no_sample_accurate_ctrl;
716 LV2Plugin::~LV2Plugin ()
718 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
723 lilv_instance_free(_impl->instance);
724 lilv_state_free(_impl->state);
725 lilv_node_free(_impl->name);
726 lilv_node_free(_impl->author);
727 #ifdef HAVE_LV2_1_2_0
728 free(_impl->options);
732 free(_make_path_feature.data);
733 free(_work_schedule_feature.data);
739 if (_atom_ev_buffers) {
740 LV2_Evbuf** b = _atom_ev_buffers;
745 free(_atom_ev_buffers);
748 delete [] _control_data;
749 delete [] _shadow_data;
751 delete [] _ev_buffers;
755 LV2Plugin::is_external_ui() const
760 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
764 LV2Plugin::is_external_kx() const
769 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
773 LV2Plugin::ui_is_resizable () const
775 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
776 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
777 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
778 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
780 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
781 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
783 lilv_nodes_free(nrs_matches);
784 lilv_nodes_free(fs_matches);
789 return !fs_matches && !nrs_matches;
793 LV2Plugin::unique_id() const
795 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
799 LV2Plugin::uri() const
801 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
805 LV2Plugin::label() const
807 return lilv_node_as_string(_impl->name);
811 LV2Plugin::name() const
813 return lilv_node_as_string(_impl->name);
817 LV2Plugin::maker() const
819 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
823 LV2Plugin::num_ports() const
825 return lilv_plugin_get_num_ports(_impl->plugin);
829 LV2Plugin::parameter_count() const
831 return lilv_plugin_get_num_ports(_impl->plugin);
835 LV2Plugin::default_value(uint32_t port)
837 return _defaults[port];
841 LV2Plugin::port_symbol(uint32_t index) const
843 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
845 error << name() << ": Invalid port index " << index << endmsg;
848 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
849 return lilv_node_as_string(sym);
853 LV2Plugin::port_index (const char* symbol) const
855 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
856 if (i != _port_indices.end()) {
859 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
865 LV2Plugin::set_parameter(uint32_t which, float val)
867 DEBUG_TRACE(DEBUG::LV2, string_compose(
868 "%1 set parameter %2 to %3\n", name(), which, val));
870 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
871 if (get_parameter (which) == val) {
875 _shadow_data[which] = val;
877 warning << string_compose(
878 _("Illegal parameter number used with plugin \"%1\". "
879 "This is a bug in either %2 or the LV2 plugin <%3>"),
880 name(), PROGRAM_NAME, unique_id()) << endmsg;
883 Plugin::set_parameter(which, val);
887 LV2Plugin::get_parameter(uint32_t which) const
889 if (parameter_is_input(which)) {
890 return (float)_shadow_data[which];
892 return (float)_control_data[which];
898 LV2Plugin::get_docs() const
900 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
902 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
903 lilv_nodes_free(comments);
911 LV2Plugin::get_parameter_docs(uint32_t which) const
913 LilvNodes* comments = lilv_port_get_value(
915 lilv_plugin_get_port_by_index(_impl->plugin, which),
916 _world.rdfs_comment);
919 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
920 lilv_nodes_free(comments);
928 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
931 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
932 if (parameter_is_control(x)) {
944 LV2Plugin::extension_data(const char* uri) const
946 return lilv_instance_get_extension_data(_impl->instance, uri);
950 LV2Plugin::c_plugin()
952 return _impl->plugin;
958 return (const void*)_impl->ui;
962 LV2Plugin::c_ui_type()
964 return (const void*)_impl->ui_type;
967 /** Directory for all plugin state. */
969 LV2Plugin::plugin_dir() const
971 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
974 /** Directory for files created by the plugin (except during save). */
976 LV2Plugin::scratch_dir() const
978 return Glib::build_filename(plugin_dir(), "scratch");
981 /** Directory for snapshots of files in the scratch directory. */
983 LV2Plugin::file_dir() const
985 return Glib::build_filename(plugin_dir(), "files");
988 /** Directory to save state snapshot version @c num into. */
990 LV2Plugin::state_dir(unsigned num) const
992 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
995 /** Implementation of state:makePath for files created at instantiation time.
996 * Note this is not used for files created at save time (Lilv deals with that).
999 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1002 LV2Plugin* me = (LV2Plugin*)handle;
1003 if (me->_insert_id == PBD::ID("0")) {
1004 warning << string_compose(
1005 "File path \"%1\" requested but LV2 %2 has no insert ID",
1006 path, me->name()) << endmsg;
1007 return g_strdup(path);
1010 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1011 const std::string dirname = Glib::path_get_dirname(abs_path);
1012 g_mkdir_with_parents(dirname.c_str(), 0744);
1014 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1017 return g_strndup(abs_path.c_str(), abs_path.length());
1021 LV2Plugin::add_state(XMLNode* root) const
1023 assert(_insert_id != PBD::ID("0"));
1027 LocaleGuard lg(X_("C"));
1029 for (uint32_t i = 0; i < parameter_count(); ++i) {
1030 if (parameter_is_input(i) && parameter_is_control(i)) {
1031 child = new XMLNode("Port");
1032 child->add_property("symbol", port_symbol(i));
1033 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1034 child->add_property("value", string(buf));
1035 root->add_child_nocopy(*child);
1039 if (_has_state_interface) {
1040 // Provisionally increment state version and create directory
1041 const std::string new_dir = state_dir(++_state_version);
1042 g_mkdir_with_parents(new_dir.c_str(), 0744);
1044 LilvState* state = lilv_state_new_from_instance(
1047 _uri_map.urid_map(),
1048 scratch_dir().c_str(),
1050 _session.externals_dir().c_str(),
1053 const_cast<LV2Plugin*>(this),
1057 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
1058 lilv_state_save(_world.world,
1059 _uri_map.urid_map(),
1060 _uri_map.urid_unmap(),
1066 lilv_state_free(_impl->state);
1067 _impl->state = state;
1069 // State is identical, decrement version and nuke directory
1070 lilv_state_free(state);
1071 PBD::remove_directory(new_dir);
1075 root->add_property("state-dir", string_compose("state%1", _state_version));
1079 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1081 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1083 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1085 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1086 lilv_nodes_free(vs);
1093 LV2Plugin::find_presets()
1095 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1096 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1097 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1099 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1100 LILV_FOREACH(nodes, i, presets) {
1101 const LilvNode* preset = lilv_nodes_get(presets, i);
1102 lilv_world_load_resource(_world.world, preset);
1103 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1105 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1106 Plugin::PresetRecord(
1107 lilv_node_as_string(preset),
1108 lilv_node_as_string(name))));
1109 lilv_node_free(name);
1111 warning << string_compose(
1112 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1113 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1114 lilv_node_as_string(preset)) << endmsg;
1117 lilv_nodes_free(presets);
1119 lilv_node_free(rdfs_label);
1120 lilv_node_free(pset_Preset);
1121 lilv_node_free(lv2_appliesTo);
1125 set_port_value(const char* port_symbol,
1131 LV2Plugin* self = (LV2Plugin*)user_data;
1132 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1133 return; // TODO: Support non-float ports
1136 const uint32_t port_index = self->port_index(port_symbol);
1137 if (port_index != (uint32_t)-1) {
1138 self->set_parameter(port_index, *(const float*)value);
1143 LV2Plugin::load_preset(PresetRecord r)
1145 LilvWorld* world = _world.world;
1146 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1147 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1150 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1151 lilv_state_free(state);
1152 Plugin::load_preset(r);
1155 lilv_node_free(pset);
1160 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1165 LV2Plugin *plugin = (LV2Plugin *) user_data;
1167 uint32_t index = plugin->port_index(port_symbol);
1168 if (index != (uint32_t) -1) {
1169 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1171 *size = sizeof(float);
1172 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1173 value = &plugin->_shadow_data[index];
1185 LV2Plugin::do_save_preset(string name)
1187 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1188 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1189 const string base_name = legalize_for_uri(name);
1190 const string file_name = base_name + ".ttl";
1191 const string bundle = Glib::build_filename(
1192 Glib::get_home_dir(),
1193 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1195 #ifdef HAVE_LILV_0_21_3
1196 /* delete reference to old preset (if any) */
1197 const PresetRecord* r = preset_by_label(name);
1199 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1201 lilv_world_unload_resource (_world.world, pset);
1202 lilv_node_free(pset);
1207 LilvState* state = lilv_state_new_from_instance(
1210 _uri_map.urid_map(),
1211 scratch_dir().c_str(), // file_dir
1212 bundle.c_str(), // copy_dir
1213 bundle.c_str(), // link_dir
1214 bundle.c_str(), // save_dir
1215 lv2plugin_get_port_value, // get_value
1216 (void*)this, // user_data
1217 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1218 _features // features
1221 lilv_state_set_label(state, name.c_str());
1223 _world.world, // world
1224 _uri_map.urid_map(), // map
1225 _uri_map.urid_unmap(), // unmap
1227 NULL, // uri (NULL = use file URI)
1228 bundle.c_str(), // dir
1229 file_name.c_str() // filename
1232 lilv_state_free(state);
1234 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1235 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1236 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1237 #ifdef HAVE_LILV_0_21_3
1238 lilv_world_unload_resource(_world.world, node_preset);
1239 lilv_world_unload_bundle(_world.world, node_bundle);
1241 lilv_world_load_bundle(_world.world, node_bundle);
1242 lilv_world_load_resource(_world.world, node_preset);
1243 lilv_node_free(node_bundle);
1244 lilv_node_free(node_preset);
1245 lilv_node_free(plug_name);
1250 LV2Plugin::do_remove_preset(string name)
1252 #ifdef HAVE_LILV_0_21_3
1253 /* Look up preset record by label (FIXME: ick, label as ID) */
1254 const PresetRecord* r = preset_by_label(name);
1259 /* Load a LilvState for the preset. */
1260 LilvWorld* world = _world.world;
1261 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1262 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1264 lilv_node_free(pset);
1268 /* Unload preset from world. */
1269 lilv_world_unload_resource(world, pset);
1271 /* Delete it from the file system. This will remove the preset file and the entry
1272 from the manifest. If this results in an empty manifest (i.e. the
1273 preset is the only thing in the bundle), then the bundle is removed. */
1274 lilv_state_delete(world, state);
1276 lilv_state_free(state);
1277 lilv_node_free(pset);
1279 /* Without lilv_state_delete(), we could delete the preset file, but this
1280 would leave a broken bundle/manifest around, so the preset would still
1281 be visible, but broken. Naively deleting a bundle is too dangerous, so
1282 we simply do not support preset deletion with older Lilv */
1286 LV2Plugin::has_editor() const
1288 return _impl->ui != NULL;
1292 LV2Plugin::has_message_output() const
1294 for (uint32_t i = 0; i < num_ports(); ++i) {
1295 if ((_port_flags[i] & PORT_SEQUENCE) &&
1296 (_port_flags[i] & PORT_OUTPUT)) {
1304 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1308 const uint8_t* body)
1310 const uint32_t buf_size = sizeof(UIMessage) + size;
1311 vector<uint8_t> buf(buf_size);
1313 UIMessage* msg = (UIMessage*)&buf[0];
1315 msg->protocol = protocol;
1317 memcpy(msg + 1, body, size);
1319 return (dest->write(&buf[0], buf_size) == buf_size);
1323 LV2Plugin::write_from_ui(uint32_t index,
1326 const uint8_t* body)
1329 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1330 /* buffer data communication from plugin UI to plugin instance.
1331 * this buffer needs to potentially hold
1332 * (port's minimumSize) * (audio-periods) / (UI-periods)
1335 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1336 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1337 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1339 * it is NOT safe to overflow (msg.size will be misinterpreted)
1341 uint32_t bufsiz = 32768;
1342 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1343 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1345 rbs = max((size_t) bufsiz * 8, rbs);
1346 _from_ui = new RingBuffer<uint8_t>(rbs);
1349 if (!write_to(_from_ui, index, protocol, size, body)) {
1350 error << "Error writing from UI to plugin" << endmsg;
1357 LV2Plugin::write_to_ui(uint32_t index,
1360 const uint8_t* body)
1362 if (!write_to(_to_ui, index, protocol, size, body)) {
1363 error << "Error writing from plugin to UI" << endmsg;
1370 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1372 switch (value.type()) {
1373 case Variant::NOTHING:
1375 case Variant::BEATS:
1376 // No atom type for this, just forge a double
1377 lv2_atom_forge_double(forge, value.get_beats().to_double());
1380 lv2_atom_forge_bool(forge, value.get_bool());
1382 case Variant::DOUBLE:
1383 lv2_atom_forge_double(forge, value.get_double());
1385 case Variant::FLOAT:
1386 lv2_atom_forge_float(forge, value.get_float());
1389 lv2_atom_forge_int(forge, value.get_int());
1392 lv2_atom_forge_long(forge, value.get_long());
1395 lv2_atom_forge_path(
1396 forge, value.get_path().c_str(), value.get_path().size());
1398 case Variant::STRING:
1399 lv2_atom_forge_string(
1400 forge, value.get_string().c_str(), value.get_string().size());
1404 forge, value.get_uri().c_str(), value.get_uri().size());
1409 /** Get a variant type from a URI, return false iff no match found. */
1411 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1413 if (uri == LV2_ATOM__Bool) {
1414 type = Variant::BOOL;
1415 } else if (uri == LV2_ATOM__Double) {
1416 type = Variant::DOUBLE;
1417 } else if (uri == LV2_ATOM__Float) {
1418 type = Variant::FLOAT;
1419 } else if (uri == LV2_ATOM__Int) {
1420 type = Variant::INT;
1421 } else if (uri == LV2_ATOM__Long) {
1422 type = Variant::LONG;
1423 } else if (uri == LV2_ATOM__Path) {
1424 type = Variant::PATH;
1425 } else if (uri == LV2_ATOM__String) {
1426 type = Variant::STRING;
1427 } else if (uri == LV2_ATOM__URI) {
1428 type = Variant::URI;
1436 LV2Plugin::set_property(uint32_t key, const Variant& value)
1438 if (_patch_port_in_index == (uint32_t)-1) {
1439 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1441 } else if (value.type() == Variant::NOTHING) {
1442 error << "LV2: set_property called with void value" << endmsg;
1446 // Set up forge to write to temporary buffer on the stack
1447 LV2_Atom_Forge* forge = &_impl->ui_forge;
1448 LV2_Atom_Forge_Frame frame;
1449 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1451 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1453 // Serialize patch:Set message to set property
1454 #ifdef HAVE_LV2_1_10_0
1455 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1456 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1457 lv2_atom_forge_urid(forge, key);
1458 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1460 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1461 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1462 lv2_atom_forge_urid(forge, key);
1463 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1466 forge_variant(forge, value);
1468 // Write message to UI=>Plugin ring
1469 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1470 write_from_ui(_patch_port_in_index,
1471 _uri_map.urids.atom_eventTransfer,
1472 lv2_atom_total_size(atom),
1473 (const uint8_t*)atom);
1476 const ParameterDescriptor&
1477 LV2Plugin::get_property_descriptor(uint32_t id) const
1479 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1480 if (p != _property_descriptors.end()) {
1483 return Plugin::get_property_descriptor(id);
1487 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1489 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1490 desc.unit = ParameterDescriptor::MIDI_NOTE;
1491 } else if (lilv_nodes_contains(units, _world.units_db)) {
1492 desc.unit = ParameterDescriptor::DB;
1493 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1494 desc.unit = ParameterDescriptor::HZ;
1496 if (lilv_nodes_size(units) > 0) {
1497 const LilvNode* unit = lilv_nodes_get_first(units);
1498 LilvNode* render = get_value(lworld, unit, _world.units_render);
1500 desc.print_fmt = lilv_node_as_string(render);
1501 lilv_node_free(render);
1507 load_parameter_descriptor(LV2World& world,
1508 ParameterDescriptor& desc,
1509 Variant::Type datatype,
1510 const LilvNode* subject)
1512 LilvWorld* lworld = _world.world;
1513 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1514 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1515 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1516 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1517 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1519 desc.label = lilv_node_as_string(label);
1521 if (def && lilv_node_is_float(def)) {
1522 desc.normal = lilv_node_as_float(def);
1524 if (minimum && lilv_node_is_float(minimum)) {
1525 desc.lower = lilv_node_as_float(minimum);
1527 if (maximum && lilv_node_is_float(maximum)) {
1528 desc.upper = lilv_node_as_float(maximum);
1530 load_parameter_descriptor_units(lworld, desc, units);
1531 desc.datatype = datatype;
1532 desc.toggled |= datatype == Variant::BOOL;
1533 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1534 desc.update_steps();
1536 lilv_nodes_free(units);
1537 lilv_node_free(label);
1538 lilv_node_free(def);
1539 lilv_node_free(minimum);
1540 lilv_node_free(maximum);
1544 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1546 LilvWorld* lworld = _world.world;
1547 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1548 LilvNodes* properties = lilv_world_find_nodes(
1549 lworld, subject, _world.patch_writable, NULL);
1550 LILV_FOREACH(nodes, p, properties) {
1551 // Get label and range
1552 const LilvNode* prop = lilv_nodes_get(properties, p);
1553 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1555 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1556 lilv_node_as_uri(prop)) << endmsg;
1560 // Convert range to variant type (TODO: support for multiple range types)
1561 Variant::Type datatype;
1562 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1563 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1564 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1568 // Add description to result
1569 ParameterDescriptor desc;
1570 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1571 desc.datatype = datatype;
1572 load_parameter_descriptor(_world, desc, datatype, prop);
1573 descs.insert(std::make_pair(desc.key, desc));
1575 lilv_node_free(range);
1577 lilv_nodes_free(properties);
1581 LV2Plugin::announce_property_values()
1583 if (_patch_port_in_index == (uint32_t)-1) {
1587 // Set up forge to write to temporary buffer on the stack
1588 LV2_Atom_Forge* forge = &_impl->ui_forge;
1589 LV2_Atom_Forge_Frame frame;
1590 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1592 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1594 // Serialize patch:Get message with no subject (implicitly plugin instance)
1595 #ifdef HAVE_LV2_1_10_0
1596 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1598 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1601 // Write message to UI=>Plugin ring
1602 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1603 write_from_ui(_patch_port_in_index,
1604 _uri_map.urids.atom_eventTransfer,
1605 lv2_atom_total_size(atom),
1606 (const uint8_t*)atom);
1610 LV2Plugin::enable_ui_emission()
1613 /* see note in LV2Plugin::write_from_ui() */
1614 uint32_t bufsiz = 32768;
1615 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1616 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1618 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1619 rbs = max((size_t) bufsiz * 8, rbs);
1620 _to_ui = new RingBuffer<uint8_t>(rbs);
1625 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1631 uint32_t read_space = _to_ui->read_space();
1632 while (read_space > sizeof(UIMessage)) {
1634 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1635 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1638 vector<uint8_t> body(msg.size);
1639 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1640 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1644 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1646 read_space -= sizeof(msg) + msg.size;
1651 LV2Plugin::work(uint32_t size, const void* data)
1653 return _impl->work_iface->work(
1654 _impl->instance->lv2_handle, work_respond, this, size, data);
1658 LV2Plugin::work_response(uint32_t size, const void* data)
1660 return _impl->work_iface->work_response(
1661 _impl->instance->lv2_handle, size, data);
1665 LV2Plugin::set_insert_id(PBD::ID id)
1667 if (_insert_id == "0") {
1669 } else if (_insert_id != id) {
1670 lilv_state_free(_impl->state);
1671 _impl->state = NULL;
1677 LV2Plugin::set_state(const XMLNode& node, int version)
1680 const XMLProperty* prop;
1681 XMLNodeConstIterator iter;
1686 LocaleGuard lg(X_("C"));
1688 if (node.name() != state_node_name()) {
1689 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1693 #ifndef NO_PLUGIN_STATE
1695 if (version < 3000) {
1696 nodes = node.children("port");
1698 nodes = node.children("Port");
1701 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1705 if ((prop = child->property("symbol")) != 0) {
1706 sym = prop->value().c_str();
1708 warning << _("LV2: port has no symbol, ignored") << endmsg;
1712 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1714 if (i != _port_indices.end()) {
1715 port_id = i->second;
1717 warning << _("LV2: port has unknown index, ignored") << endmsg;
1721 if ((prop = child->property("value")) != 0) {
1722 value = prop->value().c_str();
1724 warning << _("LV2: port has no value, ignored") << endmsg;
1728 set_parameter(port_id, atof(value));
1732 if ((prop = node.property("state-dir")) != 0) {
1733 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1734 error << string_compose(
1735 "LV2: failed to parse state version from \"%1\"",
1736 prop->value()) << endmsg;
1739 // TODO: special case track-templates
1740 // (state must be saved with the template)
1741 std::string state_file = Glib::build_filename(
1743 Glib::build_filename(prop->value(), "state.ttl"));
1745 LilvState* state = lilv_state_new_from_file(
1746 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1748 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1749 lilv_state_free(_impl->state);
1750 _impl->state = state;
1753 latency_compute_run();
1756 return Plugin::set_state(node, version);
1760 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1762 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1764 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1769 LilvNodes* portunits;
1770 LilvNode *def, *min, *max;
1771 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1772 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1774 // TODO: Once we can rely on lilv 0.18.0 being present,
1775 // load_parameter_descriptor() can be used for ports as well
1776 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1777 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1778 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1779 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1780 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1781 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1782 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1783 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1784 load_parameter_descriptor_units(_world.world, desc, portunits);
1786 if (desc.sr_dependent) {
1787 desc.lower *= _session.frame_rate ();
1788 desc.upper *= _session.frame_rate ();
1791 desc.min_unbound = false; // TODO: LV2 extension required
1792 desc.max_unbound = false; // TODO: LV2 extension required
1794 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1795 desc.scale_points = get_scale_points(which);
1797 desc.update_steps();
1799 lilv_node_free(def);
1800 lilv_node_free(min);
1801 lilv_node_free(max);
1802 lilv_nodes_free(portunits);
1808 LV2Plugin::describe_parameter(Evoral::Parameter which)
1810 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1812 if (lilv_port_has_property(_impl->plugin,
1813 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1814 return X_("hidden");
1817 if (lilv_port_has_property(_impl->plugin,
1818 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1819 return X_("hidden");
1822 if (lilv_port_has_property(_impl->plugin,
1823 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1824 return X_("latency");
1827 LilvNode* name = lilv_port_get_name(_impl->plugin,
1828 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1829 string ret(lilv_node_as_string(name));
1830 lilv_node_free(name);
1838 LV2Plugin::signal_latency() const
1840 if (_latency_control_port) {
1841 return (framecnt_t)floor(*_latency_control_port);
1847 set<Evoral::Parameter>
1848 LV2Plugin::automatable() const
1850 set<Evoral::Parameter> ret;
1852 for (uint32_t i = 0; i < parameter_count(); ++i) {
1853 if (parameter_is_input(i) && parameter_is_control(i)) {
1854 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1858 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1859 p != _property_descriptors.end();
1861 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1867 LV2Plugin::activate()
1869 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1871 if (!_was_activated) {
1872 lilv_instance_activate(_impl->instance);
1873 _was_activated = true;
1878 LV2Plugin::deactivate()
1880 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1882 if (_was_activated) {
1883 lilv_instance_deactivate(_impl->instance);
1884 _was_activated = false;
1889 LV2Plugin::cleanup()
1891 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1895 lilv_instance_free(_impl->instance);
1896 _impl->instance = NULL;
1900 LV2Plugin::allocate_atom_event_buffers()
1902 /* reserve local scratch buffers for ATOM event-queues */
1903 const LilvPlugin* p = _impl->plugin;
1905 /* count non-MIDI atom event-ports
1906 * TODO: nicely ask drobilla to make a lilv_ call for that
1908 int count_atom_out = 0;
1909 int count_atom_in = 0;
1910 int minimumSize = 32768; // TODO use a per-port minimum-size
1911 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1912 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1913 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1914 LilvNodes* buffer_types = lilv_port_get_value(
1915 p, port, _world.atom_bufferType);
1916 LilvNodes* atom_supports = lilv_port_get_value(
1917 p, port, _world.atom_supports);
1919 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1920 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1921 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1924 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1927 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1928 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1929 if (min_size && lilv_node_is_int(min_size)) {
1930 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1932 lilv_nodes_free(min_size_v);
1934 lilv_nodes_free(buffer_types);
1935 lilv_nodes_free(atom_supports);
1939 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1940 name(), count_atom_in, count_atom_out));
1942 const int total_atom_buffers = (count_atom_in + count_atom_out);
1943 if (_atom_ev_buffers || total_atom_buffers == 0) {
1947 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1948 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1949 for (int i = 0; i < total_atom_buffers; ++i ) {
1950 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1951 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1953 _atom_ev_buffers[total_atom_buffers] = 0;
1957 /** Write an ardour position/time/tempo/meter as an LV2 event.
1958 * @return true on success.
1961 write_position(LV2_Atom_Forge* forge,
1963 const TempoMetric& t,
1964 Timecode::BBT_Time& bbt,
1966 framepos_t position,
1969 const URIMap::URIDs& urids = URIMap::instance().urids;
1971 uint8_t pos_buf[256];
1972 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1973 LV2_Atom_Forge_Frame frame;
1974 #ifdef HAVE_LV2_1_10_0
1975 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1976 lv2_atom_forge_key(forge, urids.time_frame);
1977 lv2_atom_forge_long(forge, position);
1978 lv2_atom_forge_key(forge, urids.time_speed);
1979 lv2_atom_forge_float(forge, speed);
1980 lv2_atom_forge_key(forge, urids.time_barBeat);
1981 lv2_atom_forge_float(forge, bbt.beats - 1 +
1982 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1983 lv2_atom_forge_key(forge, urids.time_bar);
1984 lv2_atom_forge_long(forge, bbt.bars - 1);
1985 lv2_atom_forge_key(forge, urids.time_beatUnit);
1986 lv2_atom_forge_int(forge, t.meter().note_divisor());
1987 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1988 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1989 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1990 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1992 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1993 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1994 lv2_atom_forge_long(forge, position);
1995 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1996 lv2_atom_forge_float(forge, speed);
1997 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1998 lv2_atom_forge_float(forge, bbt.beats - 1 +
1999 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2000 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2001 lv2_atom_forge_long(forge, bbt.bars - 1);
2002 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2003 lv2_atom_forge_int(forge, t.meter().note_divisor());
2004 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2005 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2006 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2007 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2010 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2011 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2012 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2013 (const uint8_t*)(atom + 1));
2017 LV2Plugin::connect_and_run(BufferSet& bufs,
2018 ChanMapping in_map, ChanMapping out_map,
2019 pframes_t nframes, framecnt_t offset)
2021 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2022 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2024 cycles_t then = get_cycles();
2026 TempoMap& tmap = _session.tempo_map();
2027 Metrics::const_iterator metric_i = tmap.metrics_end();
2028 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2030 if (_freewheel_control_port) {
2031 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2034 if (_bpm_control_port) {
2035 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2038 ChanCount bufs_count;
2039 bufs_count.set(DataType::AUDIO, 1);
2040 bufs_count.set(DataType::MIDI, 1);
2041 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2042 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2043 uint32_t const num_ports = parameter_count();
2044 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2046 uint32_t audio_in_index = 0;
2047 uint32_t audio_out_index = 0;
2048 uint32_t midi_in_index = 0;
2049 uint32_t midi_out_index = 0;
2050 uint32_t atom_port_index = 0;
2051 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2053 uint32_t index = nil_index;
2054 PortFlags flags = _port_flags[port_index];
2056 if (flags & PORT_AUDIO) {
2057 if (flags & PORT_INPUT) {
2058 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2060 ? bufs.get_audio(index).data(offset)
2061 : silent_bufs.get_audio(0).data(offset);
2063 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2065 ? bufs.get_audio(index).data(offset)
2066 : scratch_bufs.get_audio(0).data(offset);
2068 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2069 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2070 be necessary, but the mapping is illegal in some cases. Ideally
2071 that should be fixed, but this is easier...
2073 if (flags & PORT_MIDI) {
2074 if (flags & PORT_INPUT) {
2075 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2077 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2079 if (valid && bufs.count().n_midi() > index) {
2080 /* Note, ensure_lv2_bufsize() is not RT safe!
2081 * However free()/alloc() is only called if a
2082 * plugin requires a rsz:minimumSize buffersize
2083 * and the existing buffer if smaller.
2085 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2086 _ev_buffers[port_index] = bufs.get_lv2_midi(
2087 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2089 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2090 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2091 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2095 if (valid && (flags & PORT_INPUT)) {
2096 Timecode::BBT_Time bbt;
2097 if ((flags & PORT_POSITION)) {
2098 if (_session.transport_frame() != _next_cycle_start ||
2099 _session.transport_speed() != _next_cycle_speed) {
2100 // Transport has changed, write position at cycle start
2101 tmap.bbt_time(_session.transport_frame(), bbt);
2102 write_position(&_impl->forge, _ev_buffers[port_index],
2103 tmetric, bbt, _session.transport_speed(),
2104 _session.transport_frame(), 0);
2108 // Get MIDI iterator range (empty range if no MIDI)
2109 MidiBuffer::iterator m = (index != nil_index)
2110 ? bufs.get_midi(index).begin()
2111 : silent_bufs.get_midi(0).end();
2112 MidiBuffer::iterator m_end = (index != nil_index)
2113 ? bufs.get_midi(index).end()
2116 // Now merge MIDI and any transport events into the buffer
2117 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2118 const framepos_t tend = _session.transport_frame() + nframes;
2120 while (m != m_end || (metric_i != tmap.metrics_end() &&
2121 (*metric_i)->frame() < tend)) {
2122 MetricSection* metric = (metric_i != tmap.metrics_end())
2124 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2125 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2126 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2127 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2130 tmetric.set_metric(metric);
2131 bbt = metric->start();
2132 write_position(&_impl->forge, _ev_buffers[port_index],
2133 tmetric, bbt, _session.transport_speed(),
2135 metric->frame() - _session.transport_frame());
2139 } else if (!valid) {
2140 // Nothing we understand or care about, connect to scratch
2141 // see note for midi-buffer size above
2142 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2143 0, _port_minimumSize[port_index]);
2144 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2145 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2148 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2150 continue; // Control port, leave buffer alone
2152 lilv_instance_connect_port(_impl->instance, port_index, buf);
2155 // Read messages from UI and push into appropriate buffers
2157 uint32_t read_space = _from_ui->read_space();
2158 while (read_space > sizeof(UIMessage)) {
2160 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2161 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2164 vector<uint8_t> body(msg.size);
2165 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2166 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2169 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2170 LV2_Evbuf* buf = _ev_buffers[msg.index];
2171 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2172 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2173 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2174 (const uint8_t*)(atom + 1))) {
2175 error << "Failed to write data to LV2 event buffer\n";
2178 error << "Received unknown message type from UI" << endmsg;
2180 read_space -= sizeof(UIMessage) + msg.size;
2187 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2188 PortFlags flags = _port_flags[port_index];
2191 /* TODO ask drobilla about comment
2192 * "Make Ardour event buffers generic so plugins can communicate"
2193 * in libs/ardour/buffer_set.cc:310
2195 * ideally the user could choose which of the following two modes
2196 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2198 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2199 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2200 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2201 * for quite a while at least ;)
2203 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2204 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2205 const uint32_t buf_index = out_map.get(
2206 DataType::MIDI, midi_out_index++, &valid);
2208 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2211 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2212 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2213 const uint32_t buf_index = out_map.get(
2214 DataType::MIDI, midi_out_index++, &valid);
2216 bufs.flush_lv2_midi(true, buf_index);
2221 // Write messages to UI
2222 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2223 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2224 LV2_Evbuf* buf = _ev_buffers[port_index];
2225 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2226 lv2_evbuf_is_valid(i);
2227 i = lv2_evbuf_next(i)) {
2228 uint32_t frames, subframes, type, size;
2230 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2232 // Intercept patch change messages to emit PropertyChanged signal
2233 if ((flags & PORT_PATCHMSG)) {
2234 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2235 if (atom->type == _uri_map.urids.atom_Blank ||
2236 atom->type == _uri_map.urids.atom_Object) {
2237 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2238 if (obj->body.otype == _uri_map.urids.patch_Set) {
2239 const LV2_Atom* property = NULL;
2240 const LV2_Atom* value = NULL;
2241 lv2_atom_object_get(obj,
2242 _uri_map.urids.patch_property, &property,
2243 _uri_map.urids.patch_value, &value,
2246 if (!property || !value ||
2247 property->type != _uri_map.urids.atom_URID ||
2248 value->type != _uri_map.urids.atom_Path) {
2249 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2253 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2254 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2256 // Emit PropertyChanged signal for UI
2257 // TODO: This should emit the control's Changed signal
2258 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2263 if (!_to_ui) continue;
2264 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2265 size + sizeof(LV2_Atom),
2266 data - sizeof(LV2_Atom));
2271 cycles_t now = get_cycles();
2272 set_cycles((uint32_t)(now - then));
2274 // Update expected transport information for next cycle so we can detect changes
2275 _next_cycle_speed = _session.transport_speed();
2276 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2282 LV2Plugin::parameter_is_control(uint32_t param) const
2284 assert(param < _port_flags.size());
2285 return _port_flags[param] & PORT_CONTROL;
2289 LV2Plugin::parameter_is_audio(uint32_t param) const
2291 assert(param < _port_flags.size());
2292 return _port_flags[param] & PORT_AUDIO;
2296 LV2Plugin::parameter_is_event(uint32_t param) const
2298 assert(param < _port_flags.size());
2299 return _port_flags[param] & PORT_EVENT;
2303 LV2Plugin::parameter_is_output(uint32_t param) const
2305 assert(param < _port_flags.size());
2306 return _port_flags[param] & PORT_OUTPUT;
2310 LV2Plugin::parameter_is_input(uint32_t param) const
2312 assert(param < _port_flags.size());
2313 return _port_flags[param] & PORT_INPUT;
2317 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2320 if (param < parameter_count()) {
2321 snprintf(buf, len, "%.3f", get_parameter(param));
2328 boost::shared_ptr<ScalePoints>
2329 LV2Plugin::get_scale_points(uint32_t port_index) const
2331 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2332 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2334 boost::shared_ptr<ScalePoints> ret;
2339 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2341 LILV_FOREACH(scale_points, i, points) {
2342 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2343 const LilvNode* label = lilv_scale_point_get_label(p);
2344 const LilvNode* value = lilv_scale_point_get_value(p);
2345 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2346 ret->insert(make_pair(lilv_node_as_string(label),
2347 lilv_node_as_float(value)));
2351 lilv_scale_points_free(points);
2356 LV2Plugin::run(pframes_t nframes)
2358 uint32_t const N = parameter_count();
2359 for (uint32_t i = 0; i < N; ++i) {
2360 if (parameter_is_control(i) && parameter_is_input(i)) {
2361 _control_data[i] = _shadow_data[i];
2365 lilv_instance_run(_impl->instance, nframes);
2367 if (_impl->work_iface) {
2368 _worker->emit_responses();
2369 if (_impl->work_iface->end_run) {
2370 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2376 LV2Plugin::latency_compute_run()
2378 if (!_latency_control_port) {
2382 // Run the plugin so that it can set its latency parameter
2384 bool was_activated = _was_activated;
2387 uint32_t port_index = 0;
2388 uint32_t in_index = 0;
2389 uint32_t out_index = 0;
2391 // this is done in the main thread. non realtime.
2392 const framecnt_t bufsize = _engine.samples_per_cycle();
2393 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2395 memset(buffer, 0, sizeof(float) * bufsize);
2397 // FIXME: Ensure plugins can handle in-place processing
2401 while (port_index < parameter_count()) {
2402 if (parameter_is_audio(port_index)) {
2403 if (parameter_is_input(port_index)) {
2404 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2406 } else if (parameter_is_output(port_index)) {
2407 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2416 if (was_activated) {
2423 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2425 const LilvPort* port = NULL;
2426 LilvNode* designation = lilv_new_uri(_world.world, uri);
2427 port = lilv_plugin_get_port_by_designation(
2428 plugin, _world.lv2_InputPort, designation);
2429 lilv_node_free(designation);
2431 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2436 static bool lv2_filter (const string& str, void* /*arg*/)
2438 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2440 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2444 LV2World::LV2World()
2445 : world(lilv_world_new())
2446 , _bundle_checked(false)
2448 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2449 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2450 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2451 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2452 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2453 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2454 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2455 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2456 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2457 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2458 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2459 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2460 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2461 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2462 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2463 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2464 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2465 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2466 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2467 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2468 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2469 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2470 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2471 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2472 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2473 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2474 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2475 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2476 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2477 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2478 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2479 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2480 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2481 units_render = lilv_new_uri(world, LV2_UNITS__render);
2482 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2483 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2484 units_db = lilv_new_uri(world, LV2_UNITS__db);
2485 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2486 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2487 lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2488 #ifdef HAVE_LV2_1_2_0
2489 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2490 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2491 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2496 LV2World::~LV2World()
2498 #ifdef HAVE_LV2_1_2_0
2499 lilv_node_free(bufz_nominalBlockLength);
2500 lilv_node_free(bufz_fixedBlockLength);
2501 lilv_node_free(bufz_powerOf2BlockLength);
2503 lilv_node_free(lv2_noSampleAccurateCtrl);
2504 lilv_node_free(patch_Message);
2505 lilv_node_free(patch_writable);
2506 lilv_node_free(units_hz);
2507 lilv_node_free(units_midiNote);
2508 lilv_node_free(units_db);
2509 lilv_node_free(units_unit);
2510 lilv_node_free(units_render);
2511 lilv_node_free(ui_externalkx);
2512 lilv_node_free(ui_external);
2513 lilv_node_free(ui_GtkUI);
2514 lilv_node_free(time_Position);
2515 lilv_node_free(rsz_minimumSize);
2516 lilv_node_free(rdfs_comment);
2517 lilv_node_free(rdfs_label);
2518 lilv_node_free(rdfs_range);
2519 lilv_node_free(midi_MidiEvent);
2520 lilv_node_free(lv2_enumeration);
2521 lilv_node_free(lv2_freewheeling);
2522 lilv_node_free(lv2_toggled);
2523 lilv_node_free(lv2_sampleRate);
2524 lilv_node_free(lv2_reportsLatency);
2525 lilv_node_free(lv2_integer);
2526 lilv_node_free(lv2_inPlaceBroken);
2527 lilv_node_free(lv2_OutputPort);
2528 lilv_node_free(lv2_InputPort);
2529 lilv_node_free(lv2_ControlPort);
2530 lilv_node_free(lv2_AudioPort);
2531 lilv_node_free(ext_notOnGUI);
2532 lilv_node_free(ext_logarithmic);
2533 lilv_node_free(ev_EventPort);
2534 lilv_node_free(atom_supports);
2535 lilv_node_free(atom_eventTransfer);
2536 lilv_node_free(atom_bufferType);
2537 lilv_node_free(atom_Sequence);
2538 lilv_node_free(atom_Chunk);
2539 lilv_node_free(atom_AtomPort);
2540 lilv_world_free(world);
2544 LV2World::load_bundled_plugins(bool verbose)
2546 if (!_bundle_checked) {
2548 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2551 vector<string> plugin_objects;
2552 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2553 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2554 #ifdef PLATFORM_WINDOWS
2555 string uri = "file:///" + *x + "/";
2557 string uri = "file://" + *x + "/";
2559 LilvNode *node = lilv_new_uri(world, uri.c_str());
2560 lilv_world_load_bundle(world, node);
2561 lilv_node_free(node);
2564 lilv_world_load_all(world);
2565 _bundle_checked = true;
2569 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2572 _plugin_uri = strdup(plugin_uri);
2575 LV2PluginInfo::~LV2PluginInfo()
2582 LV2PluginInfo::load(Session& session)
2586 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2587 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2588 if (!uri) { throw failed_constructor(); }
2589 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2590 if (!lp) { throw failed_constructor(); }
2591 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2592 lilv_node_free(uri);
2593 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2595 } catch (failed_constructor& err) {
2596 return PluginPtr((Plugin*)0);
2603 LV2PluginInfo::in_category (const std::string &c) const
2605 // TODO use untranslated lilv_plugin_get_class()
2606 // match gtk2_ardour/plugin_selector.cc
2607 if (category == c) {
2614 LV2PluginInfo::is_instrument () const
2616 if (category == "Instrument") {
2620 /* until we make sure that category remains untranslated in the lv2.ttl spec
2621 * and until most instruments also classify themselves as such, there's a 2nd check:
2623 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2631 LV2PluginInfo::discover()
2634 world.load_bundled_plugins();
2635 _world.load_bundled_plugins(true);
2637 PluginInfoList* plugs = new PluginInfoList;
2638 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2640 LILV_FOREACH(plugins, i, plugins) {
2641 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2642 const LilvNode* pun = lilv_plugin_get_uri(p);
2644 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2646 LilvNode* name = lilv_plugin_get_name(p);
2647 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2648 warning << "Ignoring invalid LV2 plugin "
2649 << lilv_node_as_string(lilv_plugin_get_uri(p))
2654 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2655 warning << string_compose(
2656 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2657 lilv_node_as_string(name)) << endmsg;
2658 lilv_node_free(name);
2662 #ifdef HAVE_LV2_1_2_0
2663 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2664 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2665 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2667 warning << string_compose(
2668 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2669 lilv_node_as_string(name)) << endmsg;
2670 lilv_nodes_free(required_features);
2671 lilv_node_free(name);
2674 lilv_nodes_free(required_features);
2679 info->name = string(lilv_node_as_string(name));
2680 lilv_node_free(name);
2681 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2683 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2684 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2685 info->category = lilv_node_as_string(label);
2687 LilvNode* author_name = lilv_plugin_get_author_name(p);
2688 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2689 lilv_node_free(author_name);
2691 info->path = "/NOPATH"; // Meaningless for LV2
2693 /* count atom-event-ports that feature
2694 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2696 * TODO: nicely ask drobilla to make a lilv_ call for that
2698 int count_midi_out = 0;
2699 int count_midi_in = 0;
2700 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2701 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2702 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2703 LilvNodes* buffer_types = lilv_port_get_value(
2704 p, port, world.atom_bufferType);
2705 LilvNodes* atom_supports = lilv_port_get_value(
2706 p, port, world.atom_supports);
2708 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2709 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2710 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2713 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2717 lilv_nodes_free(buffer_types);
2718 lilv_nodes_free(atom_supports);
2722 info->n_inputs.set_audio(
2723 lilv_plugin_get_num_ports_of_class(
2724 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2725 info->n_inputs.set_midi(
2726 lilv_plugin_get_num_ports_of_class(
2727 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2730 info->n_outputs.set_audio(
2731 lilv_plugin_get_num_ports_of_class(
2732 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2733 info->n_outputs.set_midi(
2734 lilv_plugin_get_num_ports_of_class(
2735 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2738 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2739 info->index = 0; // Meaningless for LV2
2741 plugs->push_back(info);