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 if (!_plugin_state_dir.empty ()){
972 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
974 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
978 /** Directory for files created by the plugin (except during save). */
980 LV2Plugin::scratch_dir() const
982 return Glib::build_filename(plugin_dir(), "scratch");
985 /** Directory for snapshots of files in the scratch directory. */
987 LV2Plugin::file_dir() const
989 return Glib::build_filename(plugin_dir(), "files");
992 /** Directory to save state snapshot version @c num into. */
994 LV2Plugin::state_dir(unsigned num) const
996 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
999 /** Implementation of state:makePath for files created at instantiation time.
1000 * Note this is not used for files created at save time (Lilv deals with that).
1003 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1006 LV2Plugin* me = (LV2Plugin*)handle;
1007 if (me->_insert_id == PBD::ID("0")) {
1008 warning << string_compose(
1009 "File path \"%1\" requested but LV2 %2 has no insert ID",
1010 path, me->name()) << endmsg;
1011 return g_strdup(path);
1014 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1015 const std::string dirname = Glib::path_get_dirname(abs_path);
1016 g_mkdir_with_parents(dirname.c_str(), 0744);
1018 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1021 return g_strndup(abs_path.c_str(), abs_path.length());
1025 LV2Plugin::add_state(XMLNode* root) const
1027 assert(_insert_id != PBD::ID("0"));
1031 LocaleGuard lg(X_("C"));
1033 for (uint32_t i = 0; i < parameter_count(); ++i) {
1034 if (parameter_is_input(i) && parameter_is_control(i)) {
1035 child = new XMLNode("Port");
1036 child->add_property("symbol", port_symbol(i));
1037 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1038 child->add_property("value", string(buf));
1039 root->add_child_nocopy(*child);
1043 if (!_plugin_state_dir.empty()) {
1044 root->add_property("template-dir", _plugin_state_dir);
1047 if (_has_state_interface) {
1048 // Provisionally increment state version and create directory
1049 const std::string new_dir = state_dir(++_state_version);
1050 g_mkdir_with_parents(new_dir.c_str(), 0744);
1052 LilvState* state = lilv_state_new_from_instance(
1055 _uri_map.urid_map(),
1056 scratch_dir().c_str(),
1058 _session.externals_dir().c_str(),
1061 const_cast<LV2Plugin*>(this),
1065 if (!_plugin_state_dir.empty()
1067 || !lilv_state_equals(state, _impl->state)) {
1068 lilv_state_save(_world.world,
1069 _uri_map.urid_map(),
1070 _uri_map.urid_unmap(),
1076 if (_plugin_state_dir.empty()) {
1077 // normal session save
1078 lilv_state_free(_impl->state);
1079 _impl->state = state;
1081 // template save (dedicated state-dir)
1082 lilv_state_free(state);
1085 // State is identical, decrement version and nuke directory
1086 lilv_state_free(state);
1087 PBD::remove_directory(new_dir);
1091 root->add_property("state-dir", string_compose("state%1", _state_version));
1095 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1097 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1099 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1101 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1102 lilv_nodes_free(vs);
1109 LV2Plugin::find_presets()
1111 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1112 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1113 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1115 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1116 LILV_FOREACH(nodes, i, presets) {
1117 const LilvNode* preset = lilv_nodes_get(presets, i);
1118 lilv_world_load_resource(_world.world, preset);
1119 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1120 bool userpreset = true; // TODO
1122 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1123 Plugin::PresetRecord(
1124 lilv_node_as_string(preset),
1125 lilv_node_as_string(name),
1127 lilv_node_free(name);
1129 warning << string_compose(
1130 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1131 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1132 lilv_node_as_string(preset)) << endmsg;
1135 lilv_nodes_free(presets);
1137 lilv_node_free(rdfs_label);
1138 lilv_node_free(pset_Preset);
1139 lilv_node_free(lv2_appliesTo);
1143 set_port_value(const char* port_symbol,
1149 LV2Plugin* self = (LV2Plugin*)user_data;
1150 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1151 return; // TODO: Support non-float ports
1154 const uint32_t port_index = self->port_index(port_symbol);
1155 if (port_index != (uint32_t)-1) {
1156 self->set_parameter(port_index, *(const float*)value);
1161 LV2Plugin::load_preset(PresetRecord r)
1163 LilvWorld* world = _world.world;
1164 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1165 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1168 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1169 lilv_state_free(state);
1170 Plugin::load_preset(r);
1173 lilv_node_free(pset);
1178 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1183 LV2Plugin *plugin = (LV2Plugin *) user_data;
1185 uint32_t index = plugin->port_index(port_symbol);
1186 if (index != (uint32_t) -1) {
1187 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1189 *size = sizeof(float);
1190 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1191 value = &plugin->_shadow_data[index];
1203 LV2Plugin::do_save_preset(string name)
1205 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1206 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1207 const string base_name = legalize_for_uri(name);
1208 const string file_name = base_name + ".ttl";
1209 const string bundle = Glib::build_filename(
1210 Glib::get_home_dir(),
1211 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1213 #ifdef HAVE_LILV_0_21_3
1214 /* delete reference to old preset (if any) */
1215 const PresetRecord* r = preset_by_label(name);
1217 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1219 lilv_world_unload_resource (_world.world, pset);
1220 lilv_node_free(pset);
1225 LilvState* state = lilv_state_new_from_instance(
1228 _uri_map.urid_map(),
1229 scratch_dir().c_str(), // file_dir
1230 bundle.c_str(), // copy_dir
1231 bundle.c_str(), // link_dir
1232 bundle.c_str(), // save_dir
1233 lv2plugin_get_port_value, // get_value
1234 (void*)this, // user_data
1235 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1236 _features // features
1239 lilv_state_set_label(state, name.c_str());
1241 _world.world, // world
1242 _uri_map.urid_map(), // map
1243 _uri_map.urid_unmap(), // unmap
1245 NULL, // uri (NULL = use file URI)
1246 bundle.c_str(), // dir
1247 file_name.c_str() // filename
1250 lilv_state_free(state);
1252 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1253 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1254 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1255 #ifdef HAVE_LILV_0_21_3
1256 lilv_world_unload_resource(_world.world, node_preset);
1257 lilv_world_unload_bundle(_world.world, node_bundle);
1259 lilv_world_load_bundle(_world.world, node_bundle);
1260 lilv_world_load_resource(_world.world, node_preset);
1261 lilv_node_free(node_bundle);
1262 lilv_node_free(node_preset);
1263 lilv_node_free(plug_name);
1268 LV2Plugin::do_remove_preset(string name)
1270 #ifdef HAVE_LILV_0_21_3
1271 /* Look up preset record by label (FIXME: ick, label as ID) */
1272 const PresetRecord* r = preset_by_label(name);
1277 /* Load a LilvState for the preset. */
1278 LilvWorld* world = _world.world;
1279 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1280 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1282 lilv_node_free(pset);
1286 /* Unload preset from world. */
1287 lilv_world_unload_resource(world, pset);
1289 /* Delete it from the file system. This will remove the preset file and the entry
1290 from the manifest. If this results in an empty manifest (i.e. the
1291 preset is the only thing in the bundle), then the bundle is removed. */
1292 lilv_state_delete(world, state);
1294 lilv_state_free(state);
1295 lilv_node_free(pset);
1297 /* Without lilv_state_delete(), we could delete the preset file, but this
1298 would leave a broken bundle/manifest around, so the preset would still
1299 be visible, but broken. Naively deleting a bundle is too dangerous, so
1300 we simply do not support preset deletion with older Lilv */
1304 LV2Plugin::has_editor() const
1306 return _impl->ui != NULL;
1310 LV2Plugin::has_message_output() const
1312 for (uint32_t i = 0; i < num_ports(); ++i) {
1313 if ((_port_flags[i] & PORT_SEQUENCE) &&
1314 (_port_flags[i] & PORT_OUTPUT)) {
1322 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1326 const uint8_t* body)
1328 const uint32_t buf_size = sizeof(UIMessage) + size;
1329 vector<uint8_t> buf(buf_size);
1331 UIMessage* msg = (UIMessage*)&buf[0];
1333 msg->protocol = protocol;
1335 memcpy(msg + 1, body, size);
1337 return (dest->write(&buf[0], buf_size) == buf_size);
1341 LV2Plugin::write_from_ui(uint32_t index,
1344 const uint8_t* body)
1347 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1348 /* buffer data communication from plugin UI to plugin instance.
1349 * this buffer needs to potentially hold
1350 * (port's minimumSize) * (audio-periods) / (UI-periods)
1353 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1354 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1355 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1357 * it is NOT safe to overflow (msg.size will be misinterpreted)
1359 uint32_t bufsiz = 32768;
1360 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1361 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1363 rbs = max((size_t) bufsiz * 8, rbs);
1364 _from_ui = new RingBuffer<uint8_t>(rbs);
1367 if (!write_to(_from_ui, index, protocol, size, body)) {
1368 error << "Error writing from UI to plugin" << endmsg;
1375 LV2Plugin::write_to_ui(uint32_t index,
1378 const uint8_t* body)
1380 if (!write_to(_to_ui, index, protocol, size, body)) {
1381 error << "Error writing from plugin to UI" << endmsg;
1388 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1390 switch (value.type()) {
1391 case Variant::NOTHING:
1393 case Variant::BEATS:
1394 // No atom type for this, just forge a double
1395 lv2_atom_forge_double(forge, value.get_beats().to_double());
1398 lv2_atom_forge_bool(forge, value.get_bool());
1400 case Variant::DOUBLE:
1401 lv2_atom_forge_double(forge, value.get_double());
1403 case Variant::FLOAT:
1404 lv2_atom_forge_float(forge, value.get_float());
1407 lv2_atom_forge_int(forge, value.get_int());
1410 lv2_atom_forge_long(forge, value.get_long());
1413 lv2_atom_forge_path(
1414 forge, value.get_path().c_str(), value.get_path().size());
1416 case Variant::STRING:
1417 lv2_atom_forge_string(
1418 forge, value.get_string().c_str(), value.get_string().size());
1422 forge, value.get_uri().c_str(), value.get_uri().size());
1427 /** Get a variant type from a URI, return false iff no match found. */
1429 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1431 if (uri == LV2_ATOM__Bool) {
1432 type = Variant::BOOL;
1433 } else if (uri == LV2_ATOM__Double) {
1434 type = Variant::DOUBLE;
1435 } else if (uri == LV2_ATOM__Float) {
1436 type = Variant::FLOAT;
1437 } else if (uri == LV2_ATOM__Int) {
1438 type = Variant::INT;
1439 } else if (uri == LV2_ATOM__Long) {
1440 type = Variant::LONG;
1441 } else if (uri == LV2_ATOM__Path) {
1442 type = Variant::PATH;
1443 } else if (uri == LV2_ATOM__String) {
1444 type = Variant::STRING;
1445 } else if (uri == LV2_ATOM__URI) {
1446 type = Variant::URI;
1454 LV2Plugin::set_property(uint32_t key, const Variant& value)
1456 if (_patch_port_in_index == (uint32_t)-1) {
1457 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1459 } else if (value.type() == Variant::NOTHING) {
1460 error << "LV2: set_property called with void value" << endmsg;
1464 // Set up forge to write to temporary buffer on the stack
1465 LV2_Atom_Forge* forge = &_impl->ui_forge;
1466 LV2_Atom_Forge_Frame frame;
1467 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1469 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1471 // Serialize patch:Set message to set property
1472 #ifdef HAVE_LV2_1_10_0
1473 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1474 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1475 lv2_atom_forge_urid(forge, key);
1476 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1478 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1479 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1480 lv2_atom_forge_urid(forge, key);
1481 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1484 forge_variant(forge, value);
1486 // Write message to UI=>Plugin ring
1487 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1488 write_from_ui(_patch_port_in_index,
1489 _uri_map.urids.atom_eventTransfer,
1490 lv2_atom_total_size(atom),
1491 (const uint8_t*)atom);
1494 const ParameterDescriptor&
1495 LV2Plugin::get_property_descriptor(uint32_t id) const
1497 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1498 if (p != _property_descriptors.end()) {
1501 return Plugin::get_property_descriptor(id);
1505 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1507 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1508 desc.unit = ParameterDescriptor::MIDI_NOTE;
1509 } else if (lilv_nodes_contains(units, _world.units_db)) {
1510 desc.unit = ParameterDescriptor::DB;
1511 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1512 desc.unit = ParameterDescriptor::HZ;
1514 if (lilv_nodes_size(units) > 0) {
1515 const LilvNode* unit = lilv_nodes_get_first(units);
1516 LilvNode* render = get_value(lworld, unit, _world.units_render);
1518 desc.print_fmt = lilv_node_as_string(render);
1519 lilv_node_free(render);
1525 load_parameter_descriptor(LV2World& world,
1526 ParameterDescriptor& desc,
1527 Variant::Type datatype,
1528 const LilvNode* subject)
1530 LilvWorld* lworld = _world.world;
1531 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1532 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1533 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1534 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1535 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1537 desc.label = lilv_node_as_string(label);
1539 if (def && lilv_node_is_float(def)) {
1540 desc.normal = lilv_node_as_float(def);
1542 if (minimum && lilv_node_is_float(minimum)) {
1543 desc.lower = lilv_node_as_float(minimum);
1545 if (maximum && lilv_node_is_float(maximum)) {
1546 desc.upper = lilv_node_as_float(maximum);
1548 load_parameter_descriptor_units(lworld, desc, units);
1549 desc.datatype = datatype;
1550 desc.toggled |= datatype == Variant::BOOL;
1551 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1552 desc.update_steps();
1554 lilv_nodes_free(units);
1555 lilv_node_free(label);
1556 lilv_node_free(def);
1557 lilv_node_free(minimum);
1558 lilv_node_free(maximum);
1562 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1564 LilvWorld* lworld = _world.world;
1565 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1566 LilvNodes* properties = lilv_world_find_nodes(
1567 lworld, subject, _world.patch_writable, NULL);
1568 LILV_FOREACH(nodes, p, properties) {
1569 // Get label and range
1570 const LilvNode* prop = lilv_nodes_get(properties, p);
1571 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1573 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1574 lilv_node_as_uri(prop)) << endmsg;
1578 // Convert range to variant type (TODO: support for multiple range types)
1579 Variant::Type datatype;
1580 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1581 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1582 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1586 // Add description to result
1587 ParameterDescriptor desc;
1588 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1589 desc.datatype = datatype;
1590 load_parameter_descriptor(_world, desc, datatype, prop);
1591 descs.insert(std::make_pair(desc.key, desc));
1593 lilv_node_free(range);
1595 lilv_nodes_free(properties);
1599 LV2Plugin::announce_property_values()
1601 if (_patch_port_in_index == (uint32_t)-1) {
1605 // Set up forge to write to temporary buffer on the stack
1606 LV2_Atom_Forge* forge = &_impl->ui_forge;
1607 LV2_Atom_Forge_Frame frame;
1608 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1610 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1612 // Serialize patch:Get message with no subject (implicitly plugin instance)
1613 #ifdef HAVE_LV2_1_10_0
1614 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1616 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1619 // Write message to UI=>Plugin ring
1620 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1621 write_from_ui(_patch_port_in_index,
1622 _uri_map.urids.atom_eventTransfer,
1623 lv2_atom_total_size(atom),
1624 (const uint8_t*)atom);
1628 LV2Plugin::enable_ui_emission()
1631 /* see note in LV2Plugin::write_from_ui() */
1632 uint32_t bufsiz = 32768;
1633 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1634 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1636 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1637 rbs = max((size_t) bufsiz * 8, rbs);
1638 _to_ui = new RingBuffer<uint8_t>(rbs);
1643 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1649 uint32_t read_space = _to_ui->read_space();
1650 while (read_space > sizeof(UIMessage)) {
1652 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1653 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1656 vector<uint8_t> body(msg.size);
1657 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1658 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1662 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1664 read_space -= sizeof(msg) + msg.size;
1669 LV2Plugin::work(uint32_t size, const void* data)
1671 return _impl->work_iface->work(
1672 _impl->instance->lv2_handle, work_respond, this, size, data);
1676 LV2Plugin::work_response(uint32_t size, const void* data)
1678 return _impl->work_iface->work_response(
1679 _impl->instance->lv2_handle, size, data);
1683 LV2Plugin::set_insert_id(PBD::ID id)
1685 if (_insert_id == "0") {
1687 } else if (_insert_id != id) {
1688 lilv_state_free(_impl->state);
1689 _impl->state = NULL;
1695 LV2Plugin::set_state_dir (const std::string& d)
1697 _plugin_state_dir = d;
1701 LV2Plugin::set_state(const XMLNode& node, int version)
1704 const XMLProperty* prop;
1705 XMLNodeConstIterator iter;
1710 LocaleGuard lg(X_("C"));
1712 if (node.name() != state_node_name()) {
1713 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1717 #ifndef NO_PLUGIN_STATE
1719 if (version < 3000) {
1720 nodes = node.children("port");
1722 nodes = node.children("Port");
1725 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1729 if ((prop = child->property("symbol")) != 0) {
1730 sym = prop->value().c_str();
1732 warning << _("LV2: port has no symbol, ignored") << endmsg;
1736 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1738 if (i != _port_indices.end()) {
1739 port_id = i->second;
1741 warning << _("LV2: port has unknown index, ignored") << endmsg;
1745 if ((prop = child->property("value")) != 0) {
1746 value = prop->value().c_str();
1748 warning << _("LV2: port has no value, ignored") << endmsg;
1752 set_parameter(port_id, atof(value));
1755 if ((prop = node.property("template-dir")) != 0) {
1756 set_state_dir (prop->value ());
1760 if ((prop = node.property("state-dir")) != 0) {
1761 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1762 error << string_compose(
1763 "LV2: failed to parse state version from \"%1\"",
1764 prop->value()) << endmsg;
1767 std::string state_file = Glib::build_filename(
1769 Glib::build_filename(prop->value(), "state.ttl"));
1771 LilvState* state = lilv_state_new_from_file(
1772 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1774 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1775 lilv_state_free(_impl->state);
1776 _impl->state = state;
1779 if (!_plugin_state_dir.empty ()) {
1780 // force save with session, next time (increment counter)
1781 lilv_state_free (_impl->state);
1782 _impl->state = NULL;
1786 latency_compute_run();
1789 return Plugin::set_state(node, version);
1793 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1795 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1797 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1802 LilvNodes* portunits;
1803 LilvNode *def, *min, *max;
1804 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1805 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1807 // TODO: Once we can rely on lilv 0.18.0 being present,
1808 // load_parameter_descriptor() can be used for ports as well
1809 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1810 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1811 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1812 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1813 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1814 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1815 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1816 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1817 load_parameter_descriptor_units(_world.world, desc, portunits);
1819 if (desc.sr_dependent) {
1820 desc.lower *= _session.frame_rate ();
1821 desc.upper *= _session.frame_rate ();
1824 desc.min_unbound = false; // TODO: LV2 extension required
1825 desc.max_unbound = false; // TODO: LV2 extension required
1827 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1828 desc.scale_points = get_scale_points(which);
1830 desc.update_steps();
1832 lilv_node_free(def);
1833 lilv_node_free(min);
1834 lilv_node_free(max);
1835 lilv_nodes_free(portunits);
1841 LV2Plugin::describe_parameter(Evoral::Parameter which)
1843 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1845 if (lilv_port_has_property(_impl->plugin,
1846 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1847 return X_("hidden");
1850 if (lilv_port_has_property(_impl->plugin,
1851 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1852 return X_("hidden");
1855 if (lilv_port_has_property(_impl->plugin,
1856 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1857 return X_("latency");
1860 LilvNode* name = lilv_port_get_name(_impl->plugin,
1861 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1862 string ret(lilv_node_as_string(name));
1863 lilv_node_free(name);
1871 LV2Plugin::signal_latency() const
1873 if (_latency_control_port) {
1874 return (framecnt_t)floor(*_latency_control_port);
1880 set<Evoral::Parameter>
1881 LV2Plugin::automatable() const
1883 set<Evoral::Parameter> ret;
1885 for (uint32_t i = 0; i < parameter_count(); ++i) {
1886 if (parameter_is_input(i) && parameter_is_control(i)) {
1887 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1891 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1892 p != _property_descriptors.end();
1894 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1900 LV2Plugin::activate()
1902 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1904 if (!_was_activated) {
1905 lilv_instance_activate(_impl->instance);
1906 _was_activated = true;
1911 LV2Plugin::deactivate()
1913 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1915 if (_was_activated) {
1916 lilv_instance_deactivate(_impl->instance);
1917 _was_activated = false;
1922 LV2Plugin::cleanup()
1924 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1927 lilv_instance_free(_impl->instance);
1928 _impl->instance = NULL;
1932 LV2Plugin::allocate_atom_event_buffers()
1934 /* reserve local scratch buffers for ATOM event-queues */
1935 const LilvPlugin* p = _impl->plugin;
1937 /* count non-MIDI atom event-ports
1938 * TODO: nicely ask drobilla to make a lilv_ call for that
1940 int count_atom_out = 0;
1941 int count_atom_in = 0;
1942 int minimumSize = 32768; // TODO use a per-port minimum-size
1943 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1944 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1945 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1946 LilvNodes* buffer_types = lilv_port_get_value(
1947 p, port, _world.atom_bufferType);
1948 LilvNodes* atom_supports = lilv_port_get_value(
1949 p, port, _world.atom_supports);
1951 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1952 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1953 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1956 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1959 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1960 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1961 if (min_size && lilv_node_is_int(min_size)) {
1962 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1964 lilv_nodes_free(min_size_v);
1966 lilv_nodes_free(buffer_types);
1967 lilv_nodes_free(atom_supports);
1971 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1972 name(), count_atom_in, count_atom_out));
1974 const int total_atom_buffers = (count_atom_in + count_atom_out);
1975 if (_atom_ev_buffers || total_atom_buffers == 0) {
1979 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1980 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1981 for (int i = 0; i < total_atom_buffers; ++i ) {
1982 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1983 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1985 _atom_ev_buffers[total_atom_buffers] = 0;
1989 /** Write an ardour position/time/tempo/meter as an LV2 event.
1990 * @return true on success.
1993 write_position(LV2_Atom_Forge* forge,
1995 const TempoMetric& t,
1996 Timecode::BBT_Time& bbt,
1998 framepos_t position,
2001 const URIMap::URIDs& urids = URIMap::instance().urids;
2003 uint8_t pos_buf[256];
2004 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2005 LV2_Atom_Forge_Frame frame;
2006 #ifdef HAVE_LV2_1_10_0
2007 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2008 lv2_atom_forge_key(forge, urids.time_frame);
2009 lv2_atom_forge_long(forge, position);
2010 lv2_atom_forge_key(forge, urids.time_speed);
2011 lv2_atom_forge_float(forge, speed);
2012 lv2_atom_forge_key(forge, urids.time_barBeat);
2013 lv2_atom_forge_float(forge, bbt.beats - 1 +
2014 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2015 lv2_atom_forge_key(forge, urids.time_bar);
2016 lv2_atom_forge_long(forge, bbt.bars - 1);
2017 lv2_atom_forge_key(forge, urids.time_beatUnit);
2018 lv2_atom_forge_int(forge, t.meter().note_divisor());
2019 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2020 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2021 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2022 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2024 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2025 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2026 lv2_atom_forge_long(forge, position);
2027 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2028 lv2_atom_forge_float(forge, speed);
2029 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2030 lv2_atom_forge_float(forge, bbt.beats - 1 +
2031 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2032 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2033 lv2_atom_forge_long(forge, bbt.bars - 1);
2034 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2035 lv2_atom_forge_int(forge, t.meter().note_divisor());
2036 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2037 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2038 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2039 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2042 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2043 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2044 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2045 (const uint8_t*)(atom + 1));
2049 LV2Plugin::connect_and_run(BufferSet& bufs,
2050 ChanMapping in_map, ChanMapping out_map,
2051 pframes_t nframes, framecnt_t offset)
2053 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2054 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2056 cycles_t then = get_cycles();
2058 TempoMap& tmap = _session.tempo_map();
2059 Metrics::const_iterator metric_i = tmap.metrics_end();
2060 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2062 if (_freewheel_control_port) {
2063 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2066 if (_bpm_control_port) {
2067 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2070 ChanCount bufs_count;
2071 bufs_count.set(DataType::AUDIO, 1);
2072 bufs_count.set(DataType::MIDI, 1);
2073 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2074 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2075 uint32_t const num_ports = parameter_count();
2076 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2078 uint32_t audio_in_index = 0;
2079 uint32_t audio_out_index = 0;
2080 uint32_t midi_in_index = 0;
2081 uint32_t midi_out_index = 0;
2082 uint32_t atom_port_index = 0;
2083 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2085 uint32_t index = nil_index;
2086 PortFlags flags = _port_flags[port_index];
2088 if (flags & PORT_AUDIO) {
2089 if (flags & PORT_INPUT) {
2090 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2092 ? bufs.get_audio(index).data(offset)
2093 : silent_bufs.get_audio(0).data(offset);
2095 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2097 ? bufs.get_audio(index).data(offset)
2098 : scratch_bufs.get_audio(0).data(offset);
2100 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2101 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2102 be necessary, but the mapping is illegal in some cases. Ideally
2103 that should be fixed, but this is easier...
2105 if (flags & PORT_MIDI) {
2106 if (flags & PORT_INPUT) {
2107 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2109 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2111 if (valid && bufs.count().n_midi() > index) {
2112 /* Note, ensure_lv2_bufsize() is not RT safe!
2113 * However free()/alloc() is only called if a
2114 * plugin requires a rsz:minimumSize buffersize
2115 * and the existing buffer if smaller.
2117 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2118 _ev_buffers[port_index] = bufs.get_lv2_midi(
2119 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2121 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2122 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2123 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2127 if (valid && (flags & PORT_INPUT)) {
2128 Timecode::BBT_Time bbt;
2129 if ((flags & PORT_POSITION)) {
2130 if (_session.transport_frame() != _next_cycle_start ||
2131 _session.transport_speed() != _next_cycle_speed) {
2132 // Transport has changed, write position at cycle start
2133 tmap.bbt_time(_session.transport_frame(), bbt);
2134 write_position(&_impl->forge, _ev_buffers[port_index],
2135 tmetric, bbt, _session.transport_speed(),
2136 _session.transport_frame(), 0);
2140 // Get MIDI iterator range (empty range if no MIDI)
2141 MidiBuffer::iterator m = (index != nil_index)
2142 ? bufs.get_midi(index).begin()
2143 : silent_bufs.get_midi(0).end();
2144 MidiBuffer::iterator m_end = (index != nil_index)
2145 ? bufs.get_midi(index).end()
2148 // Now merge MIDI and any transport events into the buffer
2149 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2150 const framepos_t tend = _session.transport_frame() + nframes;
2152 while (m != m_end || (metric_i != tmap.metrics_end() &&
2153 (*metric_i)->frame() < tend)) {
2154 MetricSection* metric = (metric_i != tmap.metrics_end())
2156 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2157 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2158 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2159 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2162 tmetric.set_metric(metric);
2163 bbt = metric->start();
2164 write_position(&_impl->forge, _ev_buffers[port_index],
2165 tmetric, bbt, _session.transport_speed(),
2167 metric->frame() - _session.transport_frame());
2171 } else if (!valid) {
2172 // Nothing we understand or care about, connect to scratch
2173 // see note for midi-buffer size above
2174 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2175 0, _port_minimumSize[port_index]);
2176 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2177 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2180 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2182 continue; // Control port, leave buffer alone
2184 lilv_instance_connect_port(_impl->instance, port_index, buf);
2187 // Read messages from UI and push into appropriate buffers
2189 uint32_t read_space = _from_ui->read_space();
2190 while (read_space > sizeof(UIMessage)) {
2192 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2193 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2196 vector<uint8_t> body(msg.size);
2197 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2198 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2201 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2202 LV2_Evbuf* buf = _ev_buffers[msg.index];
2203 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2204 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2205 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2206 (const uint8_t*)(atom + 1))) {
2207 error << "Failed to write data to LV2 event buffer\n";
2210 error << "Received unknown message type from UI" << endmsg;
2212 read_space -= sizeof(UIMessage) + msg.size;
2219 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2220 PortFlags flags = _port_flags[port_index];
2223 /* TODO ask drobilla about comment
2224 * "Make Ardour event buffers generic so plugins can communicate"
2225 * in libs/ardour/buffer_set.cc:310
2227 * ideally the user could choose which of the following two modes
2228 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2230 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2231 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2232 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2233 * for quite a while at least ;)
2235 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2236 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2237 const uint32_t buf_index = out_map.get(
2238 DataType::MIDI, midi_out_index++, &valid);
2240 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2243 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2244 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2245 const uint32_t buf_index = out_map.get(
2246 DataType::MIDI, midi_out_index++, &valid);
2248 bufs.flush_lv2_midi(true, buf_index);
2253 // Write messages to UI
2254 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2255 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2256 LV2_Evbuf* buf = _ev_buffers[port_index];
2257 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2258 lv2_evbuf_is_valid(i);
2259 i = lv2_evbuf_next(i)) {
2260 uint32_t frames, subframes, type, size;
2262 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2264 // Intercept patch change messages to emit PropertyChanged signal
2265 if ((flags & PORT_PATCHMSG)) {
2266 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2267 if (atom->type == _uri_map.urids.atom_Blank ||
2268 atom->type == _uri_map.urids.atom_Object) {
2269 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2270 if (obj->body.otype == _uri_map.urids.patch_Set) {
2271 const LV2_Atom* property = NULL;
2272 const LV2_Atom* value = NULL;
2273 lv2_atom_object_get(obj,
2274 _uri_map.urids.patch_property, &property,
2275 _uri_map.urids.patch_value, &value,
2278 if (!property || !value ||
2279 property->type != _uri_map.urids.atom_URID ||
2280 value->type != _uri_map.urids.atom_Path) {
2281 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2285 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2286 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2288 // Emit PropertyChanged signal for UI
2289 // TODO: This should emit the control's Changed signal
2290 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2295 if (!_to_ui) continue;
2296 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2297 size + sizeof(LV2_Atom),
2298 data - sizeof(LV2_Atom));
2303 cycles_t now = get_cycles();
2304 set_cycles((uint32_t)(now - then));
2306 // Update expected transport information for next cycle so we can detect changes
2307 _next_cycle_speed = _session.transport_speed();
2308 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2314 LV2Plugin::parameter_is_control(uint32_t param) const
2316 assert(param < _port_flags.size());
2317 return _port_flags[param] & PORT_CONTROL;
2321 LV2Plugin::parameter_is_audio(uint32_t param) const
2323 assert(param < _port_flags.size());
2324 return _port_flags[param] & PORT_AUDIO;
2328 LV2Plugin::parameter_is_event(uint32_t param) const
2330 assert(param < _port_flags.size());
2331 return _port_flags[param] & PORT_EVENT;
2335 LV2Plugin::parameter_is_output(uint32_t param) const
2337 assert(param < _port_flags.size());
2338 return _port_flags[param] & PORT_OUTPUT;
2342 LV2Plugin::parameter_is_input(uint32_t param) const
2344 assert(param < _port_flags.size());
2345 return _port_flags[param] & PORT_INPUT;
2349 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2352 if (param < parameter_count()) {
2353 snprintf(buf, len, "%.3f", get_parameter(param));
2360 boost::shared_ptr<ScalePoints>
2361 LV2Plugin::get_scale_points(uint32_t port_index) const
2363 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2364 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2366 boost::shared_ptr<ScalePoints> ret;
2371 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2373 LILV_FOREACH(scale_points, i, points) {
2374 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2375 const LilvNode* label = lilv_scale_point_get_label(p);
2376 const LilvNode* value = lilv_scale_point_get_value(p);
2377 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2378 ret->insert(make_pair(lilv_node_as_string(label),
2379 lilv_node_as_float(value)));
2383 lilv_scale_points_free(points);
2388 LV2Plugin::run(pframes_t nframes)
2390 uint32_t const N = parameter_count();
2391 for (uint32_t i = 0; i < N; ++i) {
2392 if (parameter_is_control(i) && parameter_is_input(i)) {
2393 _control_data[i] = _shadow_data[i];
2397 lilv_instance_run(_impl->instance, nframes);
2399 if (_impl->work_iface) {
2400 _worker->emit_responses();
2401 if (_impl->work_iface->end_run) {
2402 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2408 LV2Plugin::latency_compute_run()
2410 if (!_latency_control_port) {
2414 // Run the plugin so that it can set its latency parameter
2416 bool was_activated = _was_activated;
2419 uint32_t port_index = 0;
2420 uint32_t in_index = 0;
2421 uint32_t out_index = 0;
2423 // this is done in the main thread. non realtime.
2424 const framecnt_t bufsize = _engine.samples_per_cycle();
2425 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2427 memset(buffer, 0, sizeof(float) * bufsize);
2429 // FIXME: Ensure plugins can handle in-place processing
2433 while (port_index < parameter_count()) {
2434 if (parameter_is_audio(port_index)) {
2435 if (parameter_is_input(port_index)) {
2436 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2438 } else if (parameter_is_output(port_index)) {
2439 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2448 if (was_activated) {
2455 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2457 const LilvPort* port = NULL;
2458 LilvNode* designation = lilv_new_uri(_world.world, uri);
2459 port = lilv_plugin_get_port_by_designation(
2460 plugin, _world.lv2_InputPort, designation);
2461 lilv_node_free(designation);
2463 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2468 static bool lv2_filter (const string& str, void* /*arg*/)
2470 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2472 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2476 LV2World::LV2World()
2477 : world(lilv_world_new())
2478 , _bundle_checked(false)
2480 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2481 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2482 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2483 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2484 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2485 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2486 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2487 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2488 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2489 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2490 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2491 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2492 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2493 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2494 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2495 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2496 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2497 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2498 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2499 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2500 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2501 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2502 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2503 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2504 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2505 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2506 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2507 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2508 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2509 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2510 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2511 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2512 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2513 units_render = lilv_new_uri(world, LV2_UNITS__render);
2514 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2515 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2516 units_db = lilv_new_uri(world, LV2_UNITS__db);
2517 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2518 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2519 lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2520 #ifdef HAVE_LV2_1_2_0
2521 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2522 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2523 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2528 LV2World::~LV2World()
2533 #ifdef HAVE_LV2_1_2_0
2534 lilv_node_free(bufz_nominalBlockLength);
2535 lilv_node_free(bufz_fixedBlockLength);
2536 lilv_node_free(bufz_powerOf2BlockLength);
2538 lilv_node_free(lv2_noSampleAccurateCtrl);
2539 lilv_node_free(patch_Message);
2540 lilv_node_free(patch_writable);
2541 lilv_node_free(units_hz);
2542 lilv_node_free(units_midiNote);
2543 lilv_node_free(units_db);
2544 lilv_node_free(units_unit);
2545 lilv_node_free(units_render);
2546 lilv_node_free(ui_externalkx);
2547 lilv_node_free(ui_external);
2548 lilv_node_free(ui_GtkUI);
2549 lilv_node_free(time_Position);
2550 lilv_node_free(rsz_minimumSize);
2551 lilv_node_free(rdfs_comment);
2552 lilv_node_free(rdfs_label);
2553 lilv_node_free(rdfs_range);
2554 lilv_node_free(midi_MidiEvent);
2555 lilv_node_free(lv2_enumeration);
2556 lilv_node_free(lv2_freewheeling);
2557 lilv_node_free(lv2_toggled);
2558 lilv_node_free(lv2_sampleRate);
2559 lilv_node_free(lv2_reportsLatency);
2560 lilv_node_free(lv2_integer);
2561 lilv_node_free(lv2_inPlaceBroken);
2562 lilv_node_free(lv2_OutputPort);
2563 lilv_node_free(lv2_InputPort);
2564 lilv_node_free(lv2_ControlPort);
2565 lilv_node_free(lv2_AudioPort);
2566 lilv_node_free(ext_notOnGUI);
2567 lilv_node_free(ext_logarithmic);
2568 lilv_node_free(ev_EventPort);
2569 lilv_node_free(atom_supports);
2570 lilv_node_free(atom_eventTransfer);
2571 lilv_node_free(atom_bufferType);
2572 lilv_node_free(atom_Sequence);
2573 lilv_node_free(atom_Chunk);
2574 lilv_node_free(atom_AtomPort);
2575 lilv_world_free(world);
2580 LV2World::load_bundled_plugins(bool verbose)
2582 if (!_bundle_checked) {
2584 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2587 vector<string> plugin_objects;
2588 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2589 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2590 #ifdef PLATFORM_WINDOWS
2591 string uri = "file:///" + *x + "/";
2593 string uri = "file://" + *x + "/";
2595 LilvNode *node = lilv_new_uri(world, uri.c_str());
2596 lilv_world_load_bundle(world, node);
2597 lilv_node_free(node);
2600 lilv_world_load_all(world);
2601 _bundle_checked = true;
2605 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2608 _plugin_uri = strdup(plugin_uri);
2611 LV2PluginInfo::~LV2PluginInfo()
2618 LV2PluginInfo::load(Session& session)
2622 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2623 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2624 if (!uri) { throw failed_constructor(); }
2625 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2626 if (!lp) { throw failed_constructor(); }
2627 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2628 lilv_node_free(uri);
2629 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2631 } catch (failed_constructor& err) {
2632 return PluginPtr((Plugin*)0);
2638 std::vector<Plugin::PresetRecord>
2639 LV2PluginInfo::get_presets (bool /*user_only*/) const
2641 std::vector<Plugin::PresetRecord> p;
2642 #ifndef NO_PLUGIN_STATE
2643 const LilvPlugin* lp = NULL;
2646 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2647 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2648 if (!uri) { throw failed_constructor(); }
2649 lp = lilv_plugins_get_by_uri(plugins, uri);
2650 if (!lp) { throw failed_constructor(); }
2651 lilv_node_free(uri);
2652 } catch (failed_constructor& err) {
2656 // see LV2Plugin::find_presets
2657 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
2658 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
2659 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
2661 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
2662 LILV_FOREACH(nodes, i, presets) {
2663 const LilvNode* preset = lilv_nodes_get(presets, i);
2664 lilv_world_load_resource(_world.world, preset);
2665 LilvNode* name = get_value(_world.world, preset, rdfs_label);
2666 bool userpreset = true; // TODO
2668 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
2669 lilv_node_free(name);
2672 lilv_nodes_free(presets);
2673 lilv_node_free(rdfs_label);
2674 lilv_node_free(pset_Preset);
2675 lilv_node_free(lv2_appliesTo);
2681 LV2PluginInfo::in_category (const std::string &c) const
2683 // TODO use untranslated lilv_plugin_get_class()
2684 // match gtk2_ardour/plugin_selector.cc
2685 if (category == c) {
2692 LV2PluginInfo::is_instrument () const
2694 if (category == "Instrument") {
2698 /* until we make sure that category remains untranslated in the lv2.ttl spec
2699 * and until most instruments also classify themselves as such, there's a 2nd check:
2701 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2709 LV2PluginInfo::discover()
2712 world.load_bundled_plugins();
2713 _world.load_bundled_plugins(true);
2715 PluginInfoList* plugs = new PluginInfoList;
2716 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2718 LILV_FOREACH(plugins, i, plugins) {
2719 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2720 const LilvNode* pun = lilv_plugin_get_uri(p);
2722 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2724 LilvNode* name = lilv_plugin_get_name(p);
2725 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2726 warning << "Ignoring invalid LV2 plugin "
2727 << lilv_node_as_string(lilv_plugin_get_uri(p))
2732 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2733 warning << string_compose(
2734 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2735 lilv_node_as_string(name)) << endmsg;
2736 lilv_node_free(name);
2740 #ifdef HAVE_LV2_1_2_0
2741 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2742 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2743 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2745 warning << string_compose(
2746 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2747 lilv_node_as_string(name)) << endmsg;
2748 lilv_nodes_free(required_features);
2749 lilv_node_free(name);
2752 lilv_nodes_free(required_features);
2757 info->name = string(lilv_node_as_string(name));
2758 lilv_node_free(name);
2759 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2761 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2762 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2763 info->category = lilv_node_as_string(label);
2765 LilvNode* author_name = lilv_plugin_get_author_name(p);
2766 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2767 lilv_node_free(author_name);
2769 info->path = "/NOPATH"; // Meaningless for LV2
2771 /* count atom-event-ports that feature
2772 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2774 * TODO: nicely ask drobilla to make a lilv_ call for that
2776 int count_midi_out = 0;
2777 int count_midi_in = 0;
2778 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2779 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2780 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2781 LilvNodes* buffer_types = lilv_port_get_value(
2782 p, port, world.atom_bufferType);
2783 LilvNodes* atom_supports = lilv_port_get_value(
2784 p, port, world.atom_supports);
2786 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2787 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2788 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2791 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2795 lilv_nodes_free(buffer_types);
2796 lilv_nodes_free(atom_supports);
2800 info->n_inputs.set_audio(
2801 lilv_plugin_get_num_ports_of_class(
2802 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2803 info->n_inputs.set_midi(
2804 lilv_plugin_get_num_ports_of_class(
2805 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2808 info->n_outputs.set_audio(
2809 lilv_plugin_get_num_ports_of_class(
2810 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2811 info->n_outputs.set_midi(
2812 lilv_plugin_get_num_ports_of_class(
2813 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2816 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2817 info->index = 0; // Meaningless for LV2
2819 plugs->push_back(info);