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 (!_impl->state || !lilv_state_equals(state, _impl->state)) {
1066 lilv_state_save(_world.world,
1067 _uri_map.urid_map(),
1068 _uri_map.urid_unmap(),
1074 lilv_state_free(_impl->state);
1075 _impl->state = state;
1077 // State is identical, decrement version and nuke directory
1078 lilv_state_free(state);
1079 PBD::remove_directory(new_dir);
1083 root->add_property("state-dir", string_compose("state%1", _state_version));
1087 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1089 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1091 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1093 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1094 lilv_nodes_free(vs);
1101 LV2Plugin::find_presets()
1103 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1104 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1105 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1107 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1108 LILV_FOREACH(nodes, i, presets) {
1109 const LilvNode* preset = lilv_nodes_get(presets, i);
1110 lilv_world_load_resource(_world.world, preset);
1111 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1112 bool userpreset = true; // TODO
1114 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1115 Plugin::PresetRecord(
1116 lilv_node_as_string(preset),
1117 lilv_node_as_string(name),
1119 lilv_node_free(name);
1121 warning << string_compose(
1122 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1123 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1124 lilv_node_as_string(preset)) << endmsg;
1127 lilv_nodes_free(presets);
1129 lilv_node_free(rdfs_label);
1130 lilv_node_free(pset_Preset);
1131 lilv_node_free(lv2_appliesTo);
1135 set_port_value(const char* port_symbol,
1141 LV2Plugin* self = (LV2Plugin*)user_data;
1142 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1143 return; // TODO: Support non-float ports
1146 const uint32_t port_index = self->port_index(port_symbol);
1147 if (port_index != (uint32_t)-1) {
1148 self->set_parameter(port_index, *(const float*)value);
1153 LV2Plugin::load_preset(PresetRecord r)
1155 LilvWorld* world = _world.world;
1156 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1157 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1160 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1161 lilv_state_free(state);
1162 Plugin::load_preset(r);
1165 lilv_node_free(pset);
1170 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1175 LV2Plugin *plugin = (LV2Plugin *) user_data;
1177 uint32_t index = plugin->port_index(port_symbol);
1178 if (index != (uint32_t) -1) {
1179 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1181 *size = sizeof(float);
1182 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1183 value = &plugin->_shadow_data[index];
1195 LV2Plugin::do_save_preset(string name)
1197 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1198 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1199 const string base_name = legalize_for_uri(name);
1200 const string file_name = base_name + ".ttl";
1201 const string bundle = Glib::build_filename(
1202 Glib::get_home_dir(),
1203 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1205 #ifdef HAVE_LILV_0_21_3
1206 /* delete reference to old preset (if any) */
1207 const PresetRecord* r = preset_by_label(name);
1209 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1211 lilv_world_unload_resource (_world.world, pset);
1212 lilv_node_free(pset);
1217 LilvState* state = lilv_state_new_from_instance(
1220 _uri_map.urid_map(),
1221 scratch_dir().c_str(), // file_dir
1222 bundle.c_str(), // copy_dir
1223 bundle.c_str(), // link_dir
1224 bundle.c_str(), // save_dir
1225 lv2plugin_get_port_value, // get_value
1226 (void*)this, // user_data
1227 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1228 _features // features
1231 lilv_state_set_label(state, name.c_str());
1233 _world.world, // world
1234 _uri_map.urid_map(), // map
1235 _uri_map.urid_unmap(), // unmap
1237 NULL, // uri (NULL = use file URI)
1238 bundle.c_str(), // dir
1239 file_name.c_str() // filename
1242 lilv_state_free(state);
1244 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1245 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1246 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1247 #ifdef HAVE_LILV_0_21_3
1248 lilv_world_unload_resource(_world.world, node_preset);
1249 lilv_world_unload_bundle(_world.world, node_bundle);
1251 lilv_world_load_bundle(_world.world, node_bundle);
1252 lilv_world_load_resource(_world.world, node_preset);
1253 lilv_node_free(node_bundle);
1254 lilv_node_free(node_preset);
1255 lilv_node_free(plug_name);
1260 LV2Plugin::do_remove_preset(string name)
1262 #ifdef HAVE_LILV_0_21_3
1263 /* Look up preset record by label (FIXME: ick, label as ID) */
1264 const PresetRecord* r = preset_by_label(name);
1269 /* Load a LilvState for the preset. */
1270 LilvWorld* world = _world.world;
1271 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1272 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1274 lilv_node_free(pset);
1278 /* Unload preset from world. */
1279 lilv_world_unload_resource(world, pset);
1281 /* Delete it from the file system. This will remove the preset file and the entry
1282 from the manifest. If this results in an empty manifest (i.e. the
1283 preset is the only thing in the bundle), then the bundle is removed. */
1284 lilv_state_delete(world, state);
1286 lilv_state_free(state);
1287 lilv_node_free(pset);
1289 /* Without lilv_state_delete(), we could delete the preset file, but this
1290 would leave a broken bundle/manifest around, so the preset would still
1291 be visible, but broken. Naively deleting a bundle is too dangerous, so
1292 we simply do not support preset deletion with older Lilv */
1296 LV2Plugin::has_editor() const
1298 return _impl->ui != NULL;
1302 LV2Plugin::has_message_output() const
1304 for (uint32_t i = 0; i < num_ports(); ++i) {
1305 if ((_port_flags[i] & PORT_SEQUENCE) &&
1306 (_port_flags[i] & PORT_OUTPUT)) {
1314 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1318 const uint8_t* body)
1320 const uint32_t buf_size = sizeof(UIMessage) + size;
1321 vector<uint8_t> buf(buf_size);
1323 UIMessage* msg = (UIMessage*)&buf[0];
1325 msg->protocol = protocol;
1327 memcpy(msg + 1, body, size);
1329 return (dest->write(&buf[0], buf_size) == buf_size);
1333 LV2Plugin::write_from_ui(uint32_t index,
1336 const uint8_t* body)
1339 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1340 /* buffer data communication from plugin UI to plugin instance.
1341 * this buffer needs to potentially hold
1342 * (port's minimumSize) * (audio-periods) / (UI-periods)
1345 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1346 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1347 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1349 * it is NOT safe to overflow (msg.size will be misinterpreted)
1351 uint32_t bufsiz = 32768;
1352 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1353 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1355 rbs = max((size_t) bufsiz * 8, rbs);
1356 _from_ui = new RingBuffer<uint8_t>(rbs);
1359 if (!write_to(_from_ui, index, protocol, size, body)) {
1360 error << "Error writing from UI to plugin" << endmsg;
1367 LV2Plugin::write_to_ui(uint32_t index,
1370 const uint8_t* body)
1372 if (!write_to(_to_ui, index, protocol, size, body)) {
1373 error << "Error writing from plugin to UI" << endmsg;
1380 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1382 switch (value.type()) {
1383 case Variant::NOTHING:
1385 case Variant::BEATS:
1386 // No atom type for this, just forge a double
1387 lv2_atom_forge_double(forge, value.get_beats().to_double());
1390 lv2_atom_forge_bool(forge, value.get_bool());
1392 case Variant::DOUBLE:
1393 lv2_atom_forge_double(forge, value.get_double());
1395 case Variant::FLOAT:
1396 lv2_atom_forge_float(forge, value.get_float());
1399 lv2_atom_forge_int(forge, value.get_int());
1402 lv2_atom_forge_long(forge, value.get_long());
1405 lv2_atom_forge_path(
1406 forge, value.get_path().c_str(), value.get_path().size());
1408 case Variant::STRING:
1409 lv2_atom_forge_string(
1410 forge, value.get_string().c_str(), value.get_string().size());
1414 forge, value.get_uri().c_str(), value.get_uri().size());
1419 /** Get a variant type from a URI, return false iff no match found. */
1421 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1423 if (uri == LV2_ATOM__Bool) {
1424 type = Variant::BOOL;
1425 } else if (uri == LV2_ATOM__Double) {
1426 type = Variant::DOUBLE;
1427 } else if (uri == LV2_ATOM__Float) {
1428 type = Variant::FLOAT;
1429 } else if (uri == LV2_ATOM__Int) {
1430 type = Variant::INT;
1431 } else if (uri == LV2_ATOM__Long) {
1432 type = Variant::LONG;
1433 } else if (uri == LV2_ATOM__Path) {
1434 type = Variant::PATH;
1435 } else if (uri == LV2_ATOM__String) {
1436 type = Variant::STRING;
1437 } else if (uri == LV2_ATOM__URI) {
1438 type = Variant::URI;
1446 LV2Plugin::set_property(uint32_t key, const Variant& value)
1448 if (_patch_port_in_index == (uint32_t)-1) {
1449 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1451 } else if (value.type() == Variant::NOTHING) {
1452 error << "LV2: set_property called with void value" << endmsg;
1456 // Set up forge to write to temporary buffer on the stack
1457 LV2_Atom_Forge* forge = &_impl->ui_forge;
1458 LV2_Atom_Forge_Frame frame;
1459 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1461 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1463 // Serialize patch:Set message to set property
1464 #ifdef HAVE_LV2_1_10_0
1465 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1466 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1467 lv2_atom_forge_urid(forge, key);
1468 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1470 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1471 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1472 lv2_atom_forge_urid(forge, key);
1473 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1476 forge_variant(forge, value);
1478 // Write message to UI=>Plugin ring
1479 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1480 write_from_ui(_patch_port_in_index,
1481 _uri_map.urids.atom_eventTransfer,
1482 lv2_atom_total_size(atom),
1483 (const uint8_t*)atom);
1486 const ParameterDescriptor&
1487 LV2Plugin::get_property_descriptor(uint32_t id) const
1489 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1490 if (p != _property_descriptors.end()) {
1493 return Plugin::get_property_descriptor(id);
1497 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1499 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1500 desc.unit = ParameterDescriptor::MIDI_NOTE;
1501 } else if (lilv_nodes_contains(units, _world.units_db)) {
1502 desc.unit = ParameterDescriptor::DB;
1503 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1504 desc.unit = ParameterDescriptor::HZ;
1506 if (lilv_nodes_size(units) > 0) {
1507 const LilvNode* unit = lilv_nodes_get_first(units);
1508 LilvNode* render = get_value(lworld, unit, _world.units_render);
1510 desc.print_fmt = lilv_node_as_string(render);
1511 lilv_node_free(render);
1517 load_parameter_descriptor(LV2World& world,
1518 ParameterDescriptor& desc,
1519 Variant::Type datatype,
1520 const LilvNode* subject)
1522 LilvWorld* lworld = _world.world;
1523 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1524 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1525 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1526 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1527 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1529 desc.label = lilv_node_as_string(label);
1531 if (def && lilv_node_is_float(def)) {
1532 desc.normal = lilv_node_as_float(def);
1534 if (minimum && lilv_node_is_float(minimum)) {
1535 desc.lower = lilv_node_as_float(minimum);
1537 if (maximum && lilv_node_is_float(maximum)) {
1538 desc.upper = lilv_node_as_float(maximum);
1540 load_parameter_descriptor_units(lworld, desc, units);
1541 desc.datatype = datatype;
1542 desc.toggled |= datatype == Variant::BOOL;
1543 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1544 desc.update_steps();
1546 lilv_nodes_free(units);
1547 lilv_node_free(label);
1548 lilv_node_free(def);
1549 lilv_node_free(minimum);
1550 lilv_node_free(maximum);
1554 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1556 LilvWorld* lworld = _world.world;
1557 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1558 LilvNodes* properties = lilv_world_find_nodes(
1559 lworld, subject, _world.patch_writable, NULL);
1560 LILV_FOREACH(nodes, p, properties) {
1561 // Get label and range
1562 const LilvNode* prop = lilv_nodes_get(properties, p);
1563 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1565 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1566 lilv_node_as_uri(prop)) << endmsg;
1570 // Convert range to variant type (TODO: support for multiple range types)
1571 Variant::Type datatype;
1572 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1573 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1574 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1578 // Add description to result
1579 ParameterDescriptor desc;
1580 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1581 desc.datatype = datatype;
1582 load_parameter_descriptor(_world, desc, datatype, prop);
1583 descs.insert(std::make_pair(desc.key, desc));
1585 lilv_node_free(range);
1587 lilv_nodes_free(properties);
1591 LV2Plugin::announce_property_values()
1593 if (_patch_port_in_index == (uint32_t)-1) {
1597 // Set up forge to write to temporary buffer on the stack
1598 LV2_Atom_Forge* forge = &_impl->ui_forge;
1599 LV2_Atom_Forge_Frame frame;
1600 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1602 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1604 // Serialize patch:Get message with no subject (implicitly plugin instance)
1605 #ifdef HAVE_LV2_1_10_0
1606 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1608 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1611 // Write message to UI=>Plugin ring
1612 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1613 write_from_ui(_patch_port_in_index,
1614 _uri_map.urids.atom_eventTransfer,
1615 lv2_atom_total_size(atom),
1616 (const uint8_t*)atom);
1620 LV2Plugin::enable_ui_emission()
1623 /* see note in LV2Plugin::write_from_ui() */
1624 uint32_t bufsiz = 32768;
1625 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1626 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1628 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1629 rbs = max((size_t) bufsiz * 8, rbs);
1630 _to_ui = new RingBuffer<uint8_t>(rbs);
1635 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1641 uint32_t read_space = _to_ui->read_space();
1642 while (read_space > sizeof(UIMessage)) {
1644 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1645 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1648 vector<uint8_t> body(msg.size);
1649 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1650 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1654 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1656 read_space -= sizeof(msg) + msg.size;
1661 LV2Plugin::work(uint32_t size, const void* data)
1663 return _impl->work_iface->work(
1664 _impl->instance->lv2_handle, work_respond, this, size, data);
1668 LV2Plugin::work_response(uint32_t size, const void* data)
1670 return _impl->work_iface->work_response(
1671 _impl->instance->lv2_handle, size, data);
1675 LV2Plugin::set_insert_id(PBD::ID id)
1677 if (_insert_id == "0") {
1679 } else if (_insert_id != id) {
1680 lilv_state_free(_impl->state);
1681 _impl->state = NULL;
1687 LV2Plugin::set_state_dir (const std::string& d)
1689 _plugin_state_dir = d;
1693 LV2Plugin::set_state(const XMLNode& node, int version)
1696 const XMLProperty* prop;
1697 XMLNodeConstIterator iter;
1702 LocaleGuard lg(X_("C"));
1704 if (node.name() != state_node_name()) {
1705 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1709 #ifndef NO_PLUGIN_STATE
1711 if (version < 3000) {
1712 nodes = node.children("port");
1714 nodes = node.children("Port");
1717 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1721 if ((prop = child->property("symbol")) != 0) {
1722 sym = prop->value().c_str();
1724 warning << _("LV2: port has no symbol, ignored") << endmsg;
1728 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1730 if (i != _port_indices.end()) {
1731 port_id = i->second;
1733 warning << _("LV2: port has unknown index, ignored") << endmsg;
1737 if ((prop = child->property("value")) != 0) {
1738 value = prop->value().c_str();
1740 warning << _("LV2: port has no value, ignored") << endmsg;
1744 set_parameter(port_id, atof(value));
1747 if ((prop = node.property("template-dir")) != 0) {
1748 set_state_dir (prop->value ());
1752 if ((prop = node.property("state-dir")) != 0) {
1753 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1754 error << string_compose(
1755 "LV2: failed to parse state version from \"%1\"",
1756 prop->value()) << endmsg;
1759 std::string state_file = Glib::build_filename(
1761 Glib::build_filename(prop->value(), "state.ttl"));
1763 LilvState* state = lilv_state_new_from_file(
1764 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1766 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1767 lilv_state_free(_impl->state);
1768 _impl->state = state;
1771 if (!_plugin_state_dir.empty ()) {
1772 // force save with session, next time (increment counter)
1773 lilv_state_free (_impl->state);
1774 _impl->state = NULL;
1778 latency_compute_run();
1781 return Plugin::set_state(node, version);
1785 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1787 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1789 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1794 LilvNodes* portunits;
1795 LilvNode *def, *min, *max;
1796 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1797 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1799 // TODO: Once we can rely on lilv 0.18.0 being present,
1800 // load_parameter_descriptor() can be used for ports as well
1801 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1802 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1803 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1804 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1805 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1806 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1807 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1808 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1809 load_parameter_descriptor_units(_world.world, desc, portunits);
1811 if (desc.sr_dependent) {
1812 desc.lower *= _session.frame_rate ();
1813 desc.upper *= _session.frame_rate ();
1816 desc.min_unbound = false; // TODO: LV2 extension required
1817 desc.max_unbound = false; // TODO: LV2 extension required
1819 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1820 desc.scale_points = get_scale_points(which);
1822 desc.update_steps();
1824 lilv_node_free(def);
1825 lilv_node_free(min);
1826 lilv_node_free(max);
1827 lilv_nodes_free(portunits);
1833 LV2Plugin::describe_parameter(Evoral::Parameter which)
1835 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1837 if (lilv_port_has_property(_impl->plugin,
1838 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1839 return X_("hidden");
1842 if (lilv_port_has_property(_impl->plugin,
1843 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1844 return X_("hidden");
1847 if (lilv_port_has_property(_impl->plugin,
1848 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1849 return X_("latency");
1852 LilvNode* name = lilv_port_get_name(_impl->plugin,
1853 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1854 string ret(lilv_node_as_string(name));
1855 lilv_node_free(name);
1863 LV2Plugin::signal_latency() const
1865 if (_latency_control_port) {
1866 return (framecnt_t)floor(*_latency_control_port);
1872 set<Evoral::Parameter>
1873 LV2Plugin::automatable() const
1875 set<Evoral::Parameter> ret;
1877 for (uint32_t i = 0; i < parameter_count(); ++i) {
1878 if (parameter_is_input(i) && parameter_is_control(i)) {
1879 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1883 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1884 p != _property_descriptors.end();
1886 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1892 LV2Plugin::activate()
1894 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1896 if (!_was_activated) {
1897 lilv_instance_activate(_impl->instance);
1898 _was_activated = true;
1903 LV2Plugin::deactivate()
1905 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1907 if (_was_activated) {
1908 lilv_instance_deactivate(_impl->instance);
1909 _was_activated = false;
1914 LV2Plugin::cleanup()
1916 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1919 lilv_instance_free(_impl->instance);
1920 _impl->instance = NULL;
1924 LV2Plugin::allocate_atom_event_buffers()
1926 /* reserve local scratch buffers for ATOM event-queues */
1927 const LilvPlugin* p = _impl->plugin;
1929 /* count non-MIDI atom event-ports
1930 * TODO: nicely ask drobilla to make a lilv_ call for that
1932 int count_atom_out = 0;
1933 int count_atom_in = 0;
1934 int minimumSize = 32768; // TODO use a per-port minimum-size
1935 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1936 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1937 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1938 LilvNodes* buffer_types = lilv_port_get_value(
1939 p, port, _world.atom_bufferType);
1940 LilvNodes* atom_supports = lilv_port_get_value(
1941 p, port, _world.atom_supports);
1943 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1944 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1945 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1948 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1951 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1952 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1953 if (min_size && lilv_node_is_int(min_size)) {
1954 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1956 lilv_nodes_free(min_size_v);
1958 lilv_nodes_free(buffer_types);
1959 lilv_nodes_free(atom_supports);
1963 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1964 name(), count_atom_in, count_atom_out));
1966 const int total_atom_buffers = (count_atom_in + count_atom_out);
1967 if (_atom_ev_buffers || total_atom_buffers == 0) {
1971 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1972 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1973 for (int i = 0; i < total_atom_buffers; ++i ) {
1974 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1975 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1977 _atom_ev_buffers[total_atom_buffers] = 0;
1981 /** Write an ardour position/time/tempo/meter as an LV2 event.
1982 * @return true on success.
1985 write_position(LV2_Atom_Forge* forge,
1987 const TempoMetric& t,
1988 Timecode::BBT_Time& bbt,
1990 framepos_t position,
1993 const URIMap::URIDs& urids = URIMap::instance().urids;
1995 uint8_t pos_buf[256];
1996 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1997 LV2_Atom_Forge_Frame frame;
1998 #ifdef HAVE_LV2_1_10_0
1999 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2000 lv2_atom_forge_key(forge, urids.time_frame);
2001 lv2_atom_forge_long(forge, position);
2002 lv2_atom_forge_key(forge, urids.time_speed);
2003 lv2_atom_forge_float(forge, speed);
2004 lv2_atom_forge_key(forge, urids.time_barBeat);
2005 lv2_atom_forge_float(forge, bbt.beats - 1 +
2006 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2007 lv2_atom_forge_key(forge, urids.time_bar);
2008 lv2_atom_forge_long(forge, bbt.bars - 1);
2009 lv2_atom_forge_key(forge, urids.time_beatUnit);
2010 lv2_atom_forge_int(forge, t.meter().note_divisor());
2011 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2012 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2013 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2014 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2016 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2017 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2018 lv2_atom_forge_long(forge, position);
2019 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2020 lv2_atom_forge_float(forge, speed);
2021 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2022 lv2_atom_forge_float(forge, bbt.beats - 1 +
2023 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2024 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2025 lv2_atom_forge_long(forge, bbt.bars - 1);
2026 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2027 lv2_atom_forge_int(forge, t.meter().note_divisor());
2028 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2029 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2030 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2031 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2034 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2035 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2036 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2037 (const uint8_t*)(atom + 1));
2041 LV2Plugin::connect_and_run(BufferSet& bufs,
2042 ChanMapping in_map, ChanMapping out_map,
2043 pframes_t nframes, framecnt_t offset)
2045 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2046 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2048 cycles_t then = get_cycles();
2050 TempoMap& tmap = _session.tempo_map();
2051 Metrics::const_iterator metric_i = tmap.metrics_end();
2052 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2054 if (_freewheel_control_port) {
2055 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2058 if (_bpm_control_port) {
2059 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2062 ChanCount bufs_count;
2063 bufs_count.set(DataType::AUDIO, 1);
2064 bufs_count.set(DataType::MIDI, 1);
2065 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2066 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2067 uint32_t const num_ports = parameter_count();
2068 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2070 uint32_t audio_in_index = 0;
2071 uint32_t audio_out_index = 0;
2072 uint32_t midi_in_index = 0;
2073 uint32_t midi_out_index = 0;
2074 uint32_t atom_port_index = 0;
2075 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2077 uint32_t index = nil_index;
2078 PortFlags flags = _port_flags[port_index];
2080 if (flags & PORT_AUDIO) {
2081 if (flags & PORT_INPUT) {
2082 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2084 ? bufs.get_audio(index).data(offset)
2085 : silent_bufs.get_audio(0).data(offset);
2087 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2089 ? bufs.get_audio(index).data(offset)
2090 : scratch_bufs.get_audio(0).data(offset);
2092 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2093 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2094 be necessary, but the mapping is illegal in some cases. Ideally
2095 that should be fixed, but this is easier...
2097 if (flags & PORT_MIDI) {
2098 if (flags & PORT_INPUT) {
2099 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2101 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2103 if (valid && bufs.count().n_midi() > index) {
2104 /* Note, ensure_lv2_bufsize() is not RT safe!
2105 * However free()/alloc() is only called if a
2106 * plugin requires a rsz:minimumSize buffersize
2107 * and the existing buffer if smaller.
2109 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2110 _ev_buffers[port_index] = bufs.get_lv2_midi(
2111 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2113 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2114 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2115 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2119 if (valid && (flags & PORT_INPUT)) {
2120 Timecode::BBT_Time bbt;
2121 if ((flags & PORT_POSITION)) {
2122 if (_session.transport_frame() != _next_cycle_start ||
2123 _session.transport_speed() != _next_cycle_speed) {
2124 // Transport has changed, write position at cycle start
2125 tmap.bbt_time(_session.transport_frame(), bbt);
2126 write_position(&_impl->forge, _ev_buffers[port_index],
2127 tmetric, bbt, _session.transport_speed(),
2128 _session.transport_frame(), 0);
2132 // Get MIDI iterator range (empty range if no MIDI)
2133 MidiBuffer::iterator m = (index != nil_index)
2134 ? bufs.get_midi(index).begin()
2135 : silent_bufs.get_midi(0).end();
2136 MidiBuffer::iterator m_end = (index != nil_index)
2137 ? bufs.get_midi(index).end()
2140 // Now merge MIDI and any transport events into the buffer
2141 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2142 const framepos_t tend = _session.transport_frame() + nframes;
2144 while (m != m_end || (metric_i != tmap.metrics_end() &&
2145 (*metric_i)->frame() < tend)) {
2146 MetricSection* metric = (metric_i != tmap.metrics_end())
2148 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2149 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2150 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2151 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2154 tmetric.set_metric(metric);
2155 bbt = metric->start();
2156 write_position(&_impl->forge, _ev_buffers[port_index],
2157 tmetric, bbt, _session.transport_speed(),
2159 metric->frame() - _session.transport_frame());
2163 } else if (!valid) {
2164 // Nothing we understand or care about, connect to scratch
2165 // see note for midi-buffer size above
2166 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2167 0, _port_minimumSize[port_index]);
2168 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2169 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2172 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2174 continue; // Control port, leave buffer alone
2176 lilv_instance_connect_port(_impl->instance, port_index, buf);
2179 // Read messages from UI and push into appropriate buffers
2181 uint32_t read_space = _from_ui->read_space();
2182 while (read_space > sizeof(UIMessage)) {
2184 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2185 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2188 vector<uint8_t> body(msg.size);
2189 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2190 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2193 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2194 LV2_Evbuf* buf = _ev_buffers[msg.index];
2195 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2196 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2197 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2198 (const uint8_t*)(atom + 1))) {
2199 error << "Failed to write data to LV2 event buffer\n";
2202 error << "Received unknown message type from UI" << endmsg;
2204 read_space -= sizeof(UIMessage) + msg.size;
2211 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2212 PortFlags flags = _port_flags[port_index];
2215 /* TODO ask drobilla about comment
2216 * "Make Ardour event buffers generic so plugins can communicate"
2217 * in libs/ardour/buffer_set.cc:310
2219 * ideally the user could choose which of the following two modes
2220 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2222 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2223 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2224 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2225 * for quite a while at least ;)
2227 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2228 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2229 const uint32_t buf_index = out_map.get(
2230 DataType::MIDI, midi_out_index++, &valid);
2232 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2235 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2236 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2237 const uint32_t buf_index = out_map.get(
2238 DataType::MIDI, midi_out_index++, &valid);
2240 bufs.flush_lv2_midi(true, buf_index);
2245 // Write messages to UI
2246 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2247 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2248 LV2_Evbuf* buf = _ev_buffers[port_index];
2249 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2250 lv2_evbuf_is_valid(i);
2251 i = lv2_evbuf_next(i)) {
2252 uint32_t frames, subframes, type, size;
2254 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2256 // Intercept patch change messages to emit PropertyChanged signal
2257 if ((flags & PORT_PATCHMSG)) {
2258 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2259 if (atom->type == _uri_map.urids.atom_Blank ||
2260 atom->type == _uri_map.urids.atom_Object) {
2261 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2262 if (obj->body.otype == _uri_map.urids.patch_Set) {
2263 const LV2_Atom* property = NULL;
2264 const LV2_Atom* value = NULL;
2265 lv2_atom_object_get(obj,
2266 _uri_map.urids.patch_property, &property,
2267 _uri_map.urids.patch_value, &value,
2270 if (!property || !value ||
2271 property->type != _uri_map.urids.atom_URID ||
2272 value->type != _uri_map.urids.atom_Path) {
2273 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2277 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2278 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2280 // Emit PropertyChanged signal for UI
2281 // TODO: This should emit the control's Changed signal
2282 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2287 if (!_to_ui) continue;
2288 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2289 size + sizeof(LV2_Atom),
2290 data - sizeof(LV2_Atom));
2295 cycles_t now = get_cycles();
2296 set_cycles((uint32_t)(now - then));
2298 // Update expected transport information for next cycle so we can detect changes
2299 _next_cycle_speed = _session.transport_speed();
2300 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2306 LV2Plugin::parameter_is_control(uint32_t param) const
2308 assert(param < _port_flags.size());
2309 return _port_flags[param] & PORT_CONTROL;
2313 LV2Plugin::parameter_is_audio(uint32_t param) const
2315 assert(param < _port_flags.size());
2316 return _port_flags[param] & PORT_AUDIO;
2320 LV2Plugin::parameter_is_event(uint32_t param) const
2322 assert(param < _port_flags.size());
2323 return _port_flags[param] & PORT_EVENT;
2327 LV2Plugin::parameter_is_output(uint32_t param) const
2329 assert(param < _port_flags.size());
2330 return _port_flags[param] & PORT_OUTPUT;
2334 LV2Plugin::parameter_is_input(uint32_t param) const
2336 assert(param < _port_flags.size());
2337 return _port_flags[param] & PORT_INPUT;
2341 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2344 if (param < parameter_count()) {
2345 snprintf(buf, len, "%.3f", get_parameter(param));
2352 boost::shared_ptr<ScalePoints>
2353 LV2Plugin::get_scale_points(uint32_t port_index) const
2355 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2356 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2358 boost::shared_ptr<ScalePoints> ret;
2363 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2365 LILV_FOREACH(scale_points, i, points) {
2366 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2367 const LilvNode* label = lilv_scale_point_get_label(p);
2368 const LilvNode* value = lilv_scale_point_get_value(p);
2369 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2370 ret->insert(make_pair(lilv_node_as_string(label),
2371 lilv_node_as_float(value)));
2375 lilv_scale_points_free(points);
2380 LV2Plugin::run(pframes_t nframes)
2382 uint32_t const N = parameter_count();
2383 for (uint32_t i = 0; i < N; ++i) {
2384 if (parameter_is_control(i) && parameter_is_input(i)) {
2385 _control_data[i] = _shadow_data[i];
2389 lilv_instance_run(_impl->instance, nframes);
2391 if (_impl->work_iface) {
2392 _worker->emit_responses();
2393 if (_impl->work_iface->end_run) {
2394 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2400 LV2Plugin::latency_compute_run()
2402 if (!_latency_control_port) {
2406 // Run the plugin so that it can set its latency parameter
2408 bool was_activated = _was_activated;
2411 uint32_t port_index = 0;
2412 uint32_t in_index = 0;
2413 uint32_t out_index = 0;
2415 // this is done in the main thread. non realtime.
2416 const framecnt_t bufsize = _engine.samples_per_cycle();
2417 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2419 memset(buffer, 0, sizeof(float) * bufsize);
2421 // FIXME: Ensure plugins can handle in-place processing
2425 while (port_index < parameter_count()) {
2426 if (parameter_is_audio(port_index)) {
2427 if (parameter_is_input(port_index)) {
2428 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2430 } else if (parameter_is_output(port_index)) {
2431 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2440 if (was_activated) {
2447 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2449 const LilvPort* port = NULL;
2450 LilvNode* designation = lilv_new_uri(_world.world, uri);
2451 port = lilv_plugin_get_port_by_designation(
2452 plugin, _world.lv2_InputPort, designation);
2453 lilv_node_free(designation);
2455 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2460 static bool lv2_filter (const string& str, void* /*arg*/)
2462 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2464 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2468 LV2World::LV2World()
2469 : world(lilv_world_new())
2470 , _bundle_checked(false)
2472 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2473 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2474 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2475 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2476 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2477 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2478 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2479 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2480 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2481 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2482 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2483 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2484 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2485 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2486 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2487 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2488 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2489 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2490 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2491 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2492 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2493 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2494 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2495 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2496 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2497 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2498 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2499 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2500 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2501 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2502 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2503 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2504 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2505 units_render = lilv_new_uri(world, LV2_UNITS__render);
2506 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2507 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2508 units_db = lilv_new_uri(world, LV2_UNITS__db);
2509 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2510 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2511 lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2512 #ifdef HAVE_LV2_1_2_0
2513 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2514 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2515 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2520 LV2World::~LV2World()
2522 #ifdef HAVE_LV2_1_2_0
2523 lilv_node_free(bufz_nominalBlockLength);
2524 lilv_node_free(bufz_fixedBlockLength);
2525 lilv_node_free(bufz_powerOf2BlockLength);
2527 lilv_node_free(lv2_noSampleAccurateCtrl);
2528 lilv_node_free(patch_Message);
2529 lilv_node_free(patch_writable);
2530 lilv_node_free(units_hz);
2531 lilv_node_free(units_midiNote);
2532 lilv_node_free(units_db);
2533 lilv_node_free(units_unit);
2534 lilv_node_free(units_render);
2535 lilv_node_free(ui_externalkx);
2536 lilv_node_free(ui_external);
2537 lilv_node_free(ui_GtkUI);
2538 lilv_node_free(time_Position);
2539 lilv_node_free(rsz_minimumSize);
2540 lilv_node_free(rdfs_comment);
2541 lilv_node_free(rdfs_label);
2542 lilv_node_free(rdfs_range);
2543 lilv_node_free(midi_MidiEvent);
2544 lilv_node_free(lv2_enumeration);
2545 lilv_node_free(lv2_freewheeling);
2546 lilv_node_free(lv2_toggled);
2547 lilv_node_free(lv2_sampleRate);
2548 lilv_node_free(lv2_reportsLatency);
2549 lilv_node_free(lv2_integer);
2550 lilv_node_free(lv2_inPlaceBroken);
2551 lilv_node_free(lv2_OutputPort);
2552 lilv_node_free(lv2_InputPort);
2553 lilv_node_free(lv2_ControlPort);
2554 lilv_node_free(lv2_AudioPort);
2555 lilv_node_free(ext_notOnGUI);
2556 lilv_node_free(ext_logarithmic);
2557 lilv_node_free(ev_EventPort);
2558 lilv_node_free(atom_supports);
2559 lilv_node_free(atom_eventTransfer);
2560 lilv_node_free(atom_bufferType);
2561 lilv_node_free(atom_Sequence);
2562 lilv_node_free(atom_Chunk);
2563 lilv_node_free(atom_AtomPort);
2564 lilv_world_free(world);
2568 LV2World::load_bundled_plugins(bool verbose)
2570 if (!_bundle_checked) {
2572 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2575 vector<string> plugin_objects;
2576 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2577 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2578 #ifdef PLATFORM_WINDOWS
2579 string uri = "file:///" + *x + "/";
2581 string uri = "file://" + *x + "/";
2583 LilvNode *node = lilv_new_uri(world, uri.c_str());
2584 lilv_world_load_bundle(world, node);
2585 lilv_node_free(node);
2588 lilv_world_load_all(world);
2589 _bundle_checked = true;
2593 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2596 _plugin_uri = strdup(plugin_uri);
2599 LV2PluginInfo::~LV2PluginInfo()
2606 LV2PluginInfo::load(Session& session)
2610 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2611 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2612 if (!uri) { throw failed_constructor(); }
2613 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2614 if (!lp) { throw failed_constructor(); }
2615 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2616 lilv_node_free(uri);
2617 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2619 } catch (failed_constructor& err) {
2620 return PluginPtr((Plugin*)0);
2626 std::vector<Plugin::PresetRecord>
2627 LV2PluginInfo::get_presets (bool /*user_only*/) const
2629 std::vector<Plugin::PresetRecord> p;
2630 #ifndef NO_PLUGIN_STATE
2631 const LilvPlugin* lp = NULL;
2634 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2635 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2636 if (!uri) { throw failed_constructor(); }
2637 lp = lilv_plugins_get_by_uri(plugins, uri);
2638 if (!lp) { throw failed_constructor(); }
2639 lilv_node_free(uri);
2640 } catch (failed_constructor& err) {
2644 // see LV2Plugin::find_presets
2645 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
2646 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
2647 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
2649 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
2650 LILV_FOREACH(nodes, i, presets) {
2651 const LilvNode* preset = lilv_nodes_get(presets, i);
2652 lilv_world_load_resource(_world.world, preset);
2653 LilvNode* name = get_value(_world.world, preset, rdfs_label);
2654 bool userpreset = true; // TODO
2656 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
2657 lilv_node_free(name);
2660 lilv_nodes_free(presets);
2661 lilv_node_free(rdfs_label);
2662 lilv_node_free(pset_Preset);
2663 lilv_node_free(lv2_appliesTo);
2669 LV2PluginInfo::in_category (const std::string &c) const
2671 // TODO use untranslated lilv_plugin_get_class()
2672 // match gtk2_ardour/plugin_selector.cc
2673 if (category == c) {
2680 LV2PluginInfo::is_instrument () const
2682 if (category == "Instrument") {
2686 /* until we make sure that category remains untranslated in the lv2.ttl spec
2687 * and until most instruments also classify themselves as such, there's a 2nd check:
2689 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2697 LV2PluginInfo::discover()
2700 world.load_bundled_plugins();
2701 _world.load_bundled_plugins(true);
2703 PluginInfoList* plugs = new PluginInfoList;
2704 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2706 LILV_FOREACH(plugins, i, plugins) {
2707 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2708 const LilvNode* pun = lilv_plugin_get_uri(p);
2710 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2712 LilvNode* name = lilv_plugin_get_name(p);
2713 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2714 warning << "Ignoring invalid LV2 plugin "
2715 << lilv_node_as_string(lilv_plugin_get_uri(p))
2720 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2721 warning << string_compose(
2722 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2723 lilv_node_as_string(name)) << endmsg;
2724 lilv_node_free(name);
2728 #ifdef HAVE_LV2_1_2_0
2729 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2730 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2731 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2733 warning << string_compose(
2734 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2735 lilv_node_as_string(name)) << endmsg;
2736 lilv_nodes_free(required_features);
2737 lilv_node_free(name);
2740 lilv_nodes_free(required_features);
2745 info->name = string(lilv_node_as_string(name));
2746 lilv_node_free(name);
2747 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2749 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2750 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2751 info->category = lilv_node_as_string(label);
2753 LilvNode* author_name = lilv_plugin_get_author_name(p);
2754 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2755 lilv_node_free(author_name);
2757 info->path = "/NOPATH"; // Meaningless for LV2
2759 /* count atom-event-ports that feature
2760 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2762 * TODO: nicely ask drobilla to make a lilv_ call for that
2764 int count_midi_out = 0;
2765 int count_midi_in = 0;
2766 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2767 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2768 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2769 LilvNodes* buffer_types = lilv_port_get_value(
2770 p, port, world.atom_bufferType);
2771 LilvNodes* atom_supports = lilv_port_get_value(
2772 p, port, world.atom_supports);
2774 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2775 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2776 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2779 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2783 lilv_nodes_free(buffer_types);
2784 lilv_nodes_free(atom_supports);
2788 info->n_inputs.set_audio(
2789 lilv_plugin_get_num_ports_of_class(
2790 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2791 info->n_inputs.set_midi(
2792 lilv_plugin_get_num_ports_of_class(
2793 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2796 info->n_outputs.set_audio(
2797 lilv_plugin_get_num_ports_of_class(
2798 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2799 info->n_outputs.set_midi(
2800 lilv_plugin_get_num_ports_of_class(
2801 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2804 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2805 info->index = 0; // Meaningless for LV2
2807 plugs->push_back(info);