2 Copyright (C) 2008-2012 Paul Davis
3 Author: David Robillard
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #include <pbd/gstdio_compat.h>
29 #include <glib/gprintf.h>
32 #include <boost/utility.hpp>
34 #include "pbd/file_utils.h"
35 #include "pbd/stl_delete.h"
36 #include "pbd/compose.h"
37 #include "pbd/error.h"
38 #include "pbd/xml++.h"
40 #include "libardour-config.h"
42 #include "ardour/audio_buffer.h"
43 #include "ardour/audioengine.h"
44 #include "ardour/debug.h"
45 #include "ardour/lv2_plugin.h"
46 #include "ardour/session.h"
47 #include "ardour/tempo.h"
48 #include "ardour/types.h"
49 #include "ardour/utils.h"
50 #include "ardour/worker.h"
51 #include "ardour/search_paths.h"
56 #include <lilv/lilv.h>
58 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
59 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
60 #include "lv2/lv2plug.in/ns/ext/log/log.h"
61 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
62 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
63 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
64 #include "lv2/lv2plug.in/ns/ext/state/state.h"
65 #include "lv2/lv2plug.in/ns/ext/time/time.h"
66 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
67 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
68 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
69 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
70 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
72 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
73 #include "lv2/lv2plug.in/ns/ext/options/options.h"
76 #include "lv2_evbuf.h"
79 #include <suil/suil.h>
82 // Compatibility for old LV2
83 #ifndef LV2_ATOM_CONTENTS_CONST
84 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
85 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
87 #ifndef LV2_ATOM_BODY_CONST
88 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
90 #ifndef LV2_PATCH__property
91 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
93 #ifndef LV2_PATCH__value
94 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
96 #ifndef LV2_PATCH__writable
97 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
100 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
101 This needs to be roughly the number of cycles the UI will get around to
102 actually processing the traffic. Lower values are flakier but save memory.
104 static const size_t NBUFS = 4;
107 using namespace ARDOUR;
110 class LV2World : boost::noncopyable {
115 void load_bundled_plugins(bool verbose=false);
119 LilvNode* atom_AtomPort;
120 LilvNode* atom_Chunk;
121 LilvNode* atom_Sequence;
122 LilvNode* atom_bufferType;
123 LilvNode* atom_eventTransfer;
124 LilvNode* atom_supports;
125 LilvNode* ev_EventPort;
126 LilvNode* ext_logarithmic;
127 LilvNode* ext_notOnGUI;
128 LilvNode* lv2_AudioPort;
129 LilvNode* lv2_ControlPort;
130 LilvNode* lv2_InputPort;
131 LilvNode* lv2_OutputPort;
132 LilvNode* lv2_enumeration;
133 LilvNode* lv2_freewheeling;
134 LilvNode* lv2_inPlaceBroken;
135 LilvNode* lv2_integer;
136 LilvNode* lv2_default;
137 LilvNode* lv2_minimum;
138 LilvNode* lv2_maximum;
139 LilvNode* lv2_reportsLatency;
140 LilvNode* lv2_sampleRate;
141 LilvNode* lv2_toggled;
142 LilvNode* midi_MidiEvent;
143 LilvNode* rdfs_comment;
144 LilvNode* rdfs_label;
145 LilvNode* rdfs_range;
146 LilvNode* rsz_minimumSize;
147 LilvNode* time_Position;
149 LilvNode* ui_external;
150 LilvNode* ui_externalkx;
153 LilvNode* units_unit;
154 LilvNode* units_render;
155 LilvNode* units_midiNote;
156 LilvNode* patch_writable;
157 LilvNode* patch_Message;
158 #ifdef HAVE_LV2_1_2_0
159 LilvNode* bufz_powerOf2BlockLength;
160 LilvNode* bufz_fixedBlockLength;
161 LilvNode* bufz_nominalBlockLength;
165 bool _bundle_checked;
168 static LV2World _world;
170 /* worker extension */
172 /** Called by the plugin to schedule non-RT work. */
173 static LV2_Worker_Status
174 work_schedule(LV2_Worker_Schedule_Handle handle,
178 LV2Plugin* plugin = (LV2Plugin*)handle;
179 if (plugin->session().engine().freewheeling()) {
180 // Freewheeling, do the work immediately in this (audio) thread
181 return (LV2_Worker_Status)plugin->work(size, data);
183 // Enqueue message for the worker thread
184 return plugin->worker()->schedule(size, data) ?
185 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
189 /** Called by the plugin to respond to non-RT work. */
190 static LV2_Worker_Status
191 work_respond(LV2_Worker_Respond_Handle handle,
195 LV2Plugin* plugin = (LV2Plugin*)handle;
196 if (plugin->session().engine().freewheeling()) {
197 // Freewheeling, respond immediately in this (audio) thread
198 return (LV2_Worker_Status)plugin->work_response(size, data);
200 // Enqueue response for the worker
201 return plugin->worker()->respond(size, data) ?
202 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
209 log_vprintf(LV2_Log_Handle /*handle*/,
215 const int ret = g_vasprintf(&str, fmt, args);
216 if (type == URIMap::instance().urids.log_Error) {
217 error << str << endmsg;
218 } else if (type == URIMap::instance().urids.log_Warning) {
219 warning << str << endmsg;
220 } else if (type == URIMap::instance().urids.log_Note) {
221 info << str << endmsg;
223 // TODO: Toggleable log:Trace message support
228 log_printf(LV2_Log_Handle handle,
230 const char* fmt, ...)
234 const int ret = log_vprintf(handle, type, fmt, args);
239 struct LV2Plugin::Impl {
240 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
248 /** Find the LV2 input port with the given designation.
249 * If found, bufptrs[port_index] will be set to bufptr.
251 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
253 const LilvPlugin* plugin;
255 const LilvNode* ui_type;
258 LilvInstance* instance;
259 const LV2_Worker_Interface* work_iface;
260 const LV2_Options_Interface* opts_iface;
262 LV2_Atom_Forge forge;
263 LV2_Atom_Forge ui_forge;
264 int32_t block_length;
265 LV2_Options_Option* options;
268 LV2Plugin::LV2Plugin (AudioEngine& engine,
270 const void* c_plugin,
272 : Plugin (engine, session)
278 , _patch_port_in_index((uint32_t)-1)
279 , _patch_port_out_index((uint32_t)-1)
280 , _uri_map(URIMap::instance())
282 init(c_plugin, rate);
285 LV2Plugin::LV2Plugin (const LV2Plugin& other)
291 , _insert_id(other._insert_id)
292 , _patch_port_in_index((uint32_t)-1)
293 , _patch_port_out_index((uint32_t)-1)
294 , _uri_map(URIMap::instance())
296 init(other._impl->plugin, other._sample_rate);
298 for (uint32_t i = 0; i < parameter_count(); ++i) {
299 _control_data[i] = other._shadow_data[i];
300 _shadow_data[i] = other._shadow_data[i];
305 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
307 DEBUG_TRACE(DEBUG::LV2, "init\n");
309 _impl->plugin = (const LilvPlugin*)c_plugin;
311 _impl->ui_type = NULL;
316 _atom_ev_buffers = 0;
318 _bpm_control_port = 0;
319 _freewheel_control_port = 0;
320 _latency_control_port = 0;
321 _next_cycle_start = std::numeric_limits<framepos_t>::max();
322 _next_cycle_speed = 1.0;
323 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
325 _was_activated = false;
326 _has_state_interface = false;
327 _impl->block_length = _session.get_block_size();
329 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
330 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
331 _make_path_feature.URI = LV2_STATE__makePath;
332 _log_feature.URI = LV2_LOG__log;
333 _work_schedule_feature.URI = LV2_WORKER__schedule;
334 _work_schedule_feature.data = NULL;
335 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
336 _def_state_feature.data = NULL;
338 const LilvPlugin* plugin = _impl->plugin;
340 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
341 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
342 _has_state_interface =
343 // What plugins should have (lv2:extensionData state:Interface)
344 lilv_plugin_has_extension_data(plugin, state_iface_uri)
345 // What some outdated/incorrect ones have
346 || lilv_plugin_has_feature(plugin, state_uri);
347 lilv_node_free(state_uri);
348 lilv_node_free(state_iface_uri);
350 _features = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
351 _features[0] = &_instance_access_feature;
352 _features[1] = &_data_access_feature;
353 _features[2] = &_make_path_feature;
354 _features[3] = _uri_map.uri_map_feature();
355 _features[4] = _uri_map.urid_map_feature();
356 _features[5] = _uri_map.urid_unmap_feature();
357 _features[6] = &_log_feature;
359 unsigned n_features = 7;
360 #ifdef HAVE_LV2_1_2_0
361 _features[n_features++] = &_def_state_feature;
364 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
365 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
367 #ifdef HAVE_LV2_1_2_0
368 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
369 static const int32_t _min_block_length = 1; // may happen during split-cycles
370 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
371 /* Consider updating max-block-size whenever the buffersize changes.
372 * It requires re-instantiating the plugin (which is a non-realtime operation),
373 * so it should be done lightly and only for plugins that require it.
375 * given that the block-size can change at any time (split-cycles) ardour currently
376 * does not support plugins that require bufz_fixedBlockLength.
378 LV2_Options_Option options[] = {
379 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
380 sizeof(int32_t), atom_Int, &_min_block_length },
381 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
382 sizeof(int32_t), atom_Int, &_max_block_length },
383 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
384 sizeof(int32_t), atom_Int, &_seq_size },
385 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
386 sizeof(int32_t), atom_Int, &_impl->block_length },
387 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
390 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
391 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
393 _options_feature.URI = LV2_OPTIONS__options;
394 _options_feature.data = _impl->options;
395 _features[n_features++] = &_options_feature;
398 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
399 sizeof(LV2_State_Make_Path));
400 make_path->handle = this;
401 make_path->path = &lv2_state_make_path;
402 _make_path_feature.data = make_path;
404 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
406 log->printf = &log_printf;
407 log->vprintf = &log_vprintf;
408 _log_feature.data = log;
410 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
411 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
412 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
413 sizeof(LV2_Worker_Schedule));
414 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
415 _worker = new Worker(this, buf_size);
416 schedule->handle = this;
417 schedule->schedule_work = work_schedule;
418 _work_schedule_feature.data = schedule;
419 _features[n_features++] = &_work_schedule_feature;
421 lilv_node_free(worker_schedule);
423 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
424 _impl->name = lilv_plugin_get_name(plugin);
425 _impl->author = lilv_plugin_get_author_name(plugin);
427 if (_impl->instance == 0) {
428 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
429 throw failed_constructor();
432 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
433 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
434 _data_access_feature.data = &_data_access_extension_data;
436 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
437 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
438 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
439 LV2_WORKER__interface);
441 lilv_node_free(worker_iface_uri);
444 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
445 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
446 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
447 LV2_OPTIONS__interface);
449 lilv_node_free(options_iface_uri);
451 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
452 error << string_compose(
453 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
454 lilv_node_as_string(_impl->name)) << endmsg;
455 lilv_node_free(_impl->name);
456 lilv_node_free(_impl->author);
457 throw failed_constructor();
460 #ifdef HAVE_LV2_1_2_0
461 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
462 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
463 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
465 error << string_compose(
466 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
467 lilv_node_as_string(_impl->name)) << endmsg;
468 lilv_node_free(_impl->name);
469 lilv_node_free(_impl->author);
470 lilv_nodes_free(required_features);
471 throw failed_constructor();
473 lilv_nodes_free(required_features);
476 #ifdef HAVE_LILV_0_16_0
477 // Load default state
478 LilvState* state = lilv_state_new_from_world(
479 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
480 if (state && _has_state_interface) {
481 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
483 lilv_state_free(state);
488 const uint32_t num_ports = this->num_ports();
489 for (uint32_t i = 0; i < num_ports; ++i) {
490 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
492 size_t minimumSize = 0;
494 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
495 flags |= PORT_OUTPUT;
496 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
499 error << string_compose(
500 "LV2: \"%1\" port %2 is neither input nor output",
501 lilv_node_as_string(_impl->name), i) << endmsg;
502 throw failed_constructor();
505 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
506 flags |= PORT_CONTROL;
507 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
509 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
511 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
512 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
513 LilvNodes* buffer_types = lilv_port_get_value(
514 _impl->plugin, port, _world.atom_bufferType);
515 LilvNodes* atom_supports = lilv_port_get_value(
516 _impl->plugin, port, _world.atom_supports);
518 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
519 flags |= PORT_SEQUENCE;
520 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
523 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
524 flags |= PORT_POSITION;
526 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
527 flags |= PORT_PATCHMSG;
528 if (flags & PORT_INPUT) {
529 _patch_port_in_index = i;
531 _patch_port_out_index = i;
535 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
536 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
537 if (min_size && lilv_node_is_int(min_size)) {
538 minimumSize = lilv_node_as_int(min_size);
540 lilv_nodes_free(min_size_v);
541 lilv_nodes_free(buffer_types);
542 lilv_nodes_free(atom_supports);
544 error << string_compose(
545 "LV2: \"%1\" port %2 has no known data type",
546 lilv_node_as_string(_impl->name), i) << endmsg;
547 throw failed_constructor();
550 _port_flags.push_back(flags);
551 _port_minimumSize.push_back(minimumSize);
554 _control_data = new float[num_ports];
555 _shadow_data = new float[num_ports];
556 _defaults = new float[num_ports];
557 _ev_buffers = new LV2_Evbuf*[num_ports];
558 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
560 const bool latent = lilv_plugin_has_latency(plugin);
561 const uint32_t latency_index = (latent)
562 ? lilv_plugin_get_latency_port_index(plugin)
565 // Build an array of pointers to special parameter buffers
566 void*** params = new void**[num_ports];
567 for (uint32_t i = 0; i < num_ports; ++i) {
570 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
571 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
573 for (uint32_t i = 0; i < num_ports; ++i) {
574 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
575 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
577 // Store index in map so we can look up index by symbol
578 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
580 // Get range and default value if applicable
581 if (parameter_is_control(i)) {
583 lilv_port_get_range(plugin, port, &def, NULL, NULL);
584 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
585 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
586 _defaults[i] *= _session.frame_rate ();
590 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
592 if (latent && i == latency_index) {
593 _latency_control_port = &_control_data[i];
594 *_latency_control_port = 0;
597 if (parameter_is_input(i)) {
598 _shadow_data[i] = default_value(i);
600 *params[i] = (void*)&_shadow_data[i];
610 LilvUIs* uis = lilv_plugin_get_uis(plugin);
611 if (lilv_uis_size(uis) > 0) {
613 // Look for embeddable UI
614 LILV_FOREACH(uis, u, uis) {
615 const LilvUI* this_ui = lilv_uis_get(uis, u);
616 const LilvNode* this_ui_type = NULL;
617 if (lilv_ui_is_supported(this_ui,
621 // TODO: Multiple UI support
623 _impl->ui_type = this_ui_type;
628 // Look for Gtk native UI
629 LILV_FOREACH(uis, i, uis) {
630 const LilvUI* ui = lilv_uis_get(uis, i);
631 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
633 _impl->ui_type = _world.ui_GtkUI;
639 // If Gtk UI is not available, try to find external UI
641 LILV_FOREACH(uis, i, uis) {
642 const LilvUI* ui = lilv_uis_get(uis, i);
643 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
645 _impl->ui_type = _world.ui_external;
648 if (lilv_ui_is_a(ui, _world.ui_external)) {
650 _impl->ui_type = _world.ui_external;
656 load_supported_properties(_property_descriptors);
657 allocate_atom_event_buffers();
658 latency_compute_run();
662 LV2Plugin::set_block_size (pframes_t nframes)
664 #ifdef HAVE_LV2_1_2_0
665 if (_impl->opts_iface) {
666 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
667 _impl->block_length = nframes;
668 LV2_Options_Option block_size_option = {
669 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
670 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
672 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
678 LV2Plugin::~LV2Plugin ()
680 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
685 lilv_instance_free(_impl->instance);
686 lilv_state_free(_impl->state);
687 lilv_node_free(_impl->name);
688 lilv_node_free(_impl->author);
689 free(_impl->options);
692 free(_make_path_feature.data);
693 free(_work_schedule_feature.data);
699 if (_atom_ev_buffers) {
700 LV2_Evbuf** b = _atom_ev_buffers;
705 free(_atom_ev_buffers);
708 delete [] _control_data;
709 delete [] _shadow_data;
711 delete [] _ev_buffers;
715 LV2Plugin::is_external_ui() const
720 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
724 LV2Plugin::is_external_kx() const
729 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
733 LV2Plugin::ui_is_resizable () const
735 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
736 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
737 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
738 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
740 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
741 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
743 lilv_nodes_free(nrs_matches);
744 lilv_nodes_free(fs_matches);
749 return !fs_matches && !nrs_matches;
753 LV2Plugin::unique_id() const
755 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
759 LV2Plugin::uri() const
761 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
765 LV2Plugin::label() const
767 return lilv_node_as_string(_impl->name);
771 LV2Plugin::name() const
773 return lilv_node_as_string(_impl->name);
777 LV2Plugin::maker() const
779 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
783 LV2Plugin::num_ports() const
785 return lilv_plugin_get_num_ports(_impl->plugin);
789 LV2Plugin::parameter_count() const
791 return lilv_plugin_get_num_ports(_impl->plugin);
795 LV2Plugin::default_value(uint32_t port)
797 return _defaults[port];
801 LV2Plugin::port_symbol(uint32_t index) const
803 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
805 error << name() << ": Invalid port index " << index << endmsg;
808 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
809 return lilv_node_as_string(sym);
813 LV2Plugin::port_index (const char* symbol) const
815 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
816 if (i != _port_indices.end()) {
819 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
825 LV2Plugin::set_parameter(uint32_t which, float val)
827 DEBUG_TRACE(DEBUG::LV2, string_compose(
828 "%1 set parameter %2 to %3\n", name(), which, val));
830 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
831 if (get_parameter (which) == val) {
835 _shadow_data[which] = val;
837 warning << string_compose(
838 _("Illegal parameter number used with plugin \"%1\". "
839 "This is a bug in either %2 or the LV2 plugin <%3>"),
840 name(), PROGRAM_NAME, unique_id()) << endmsg;
843 Plugin::set_parameter(which, val);
847 LV2Plugin::get_parameter(uint32_t which) const
849 if (parameter_is_input(which)) {
850 return (float)_shadow_data[which];
852 return (float)_control_data[which];
858 LV2Plugin::get_docs() const
860 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
862 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
863 lilv_nodes_free(comments);
871 LV2Plugin::get_parameter_docs(uint32_t which) const
873 LilvNodes* comments = lilv_port_get_value(
875 lilv_plugin_get_port_by_index(_impl->plugin, which),
876 _world.rdfs_comment);
879 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
880 lilv_nodes_free(comments);
888 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
891 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
892 if (parameter_is_control(x)) {
904 LV2Plugin::extension_data(const char* uri) const
906 return lilv_instance_get_extension_data(_impl->instance, uri);
910 LV2Plugin::c_plugin()
912 return _impl->plugin;
918 return (const void*)_impl->ui;
922 LV2Plugin::c_ui_type()
924 return (const void*)_impl->ui_type;
927 /** Directory for all plugin state. */
929 LV2Plugin::plugin_dir() const
931 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
934 /** Directory for files created by the plugin (except during save). */
936 LV2Plugin::scratch_dir() const
938 return Glib::build_filename(plugin_dir(), "scratch");
941 /** Directory for snapshots of files in the scratch directory. */
943 LV2Plugin::file_dir() const
945 return Glib::build_filename(plugin_dir(), "files");
948 /** Directory to save state snapshot version @c num into. */
950 LV2Plugin::state_dir(unsigned num) const
952 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
955 /** Implementation of state:makePath for files created at instantiation time.
956 * Note this is not used for files created at save time (Lilv deals with that).
959 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
962 LV2Plugin* me = (LV2Plugin*)handle;
963 if (me->_insert_id == PBD::ID("0")) {
964 warning << string_compose(
965 "File path \"%1\" requested but LV2 %2 has no insert ID",
966 path, me->name()) << endmsg;
967 return g_strdup(path);
970 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
971 const std::string dirname = Glib::path_get_dirname(abs_path);
972 g_mkdir_with_parents(dirname.c_str(), 0744);
974 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
977 return g_strndup(abs_path.c_str(), abs_path.length());
981 LV2Plugin::add_state(XMLNode* root) const
983 assert(_insert_id != PBD::ID("0"));
987 LocaleGuard lg(X_("C"));
989 for (uint32_t i = 0; i < parameter_count(); ++i) {
990 if (parameter_is_input(i) && parameter_is_control(i)) {
991 child = new XMLNode("Port");
992 child->add_property("symbol", port_symbol(i));
993 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
994 child->add_property("value", string(buf));
995 root->add_child_nocopy(*child);
999 if (_has_state_interface) {
1000 // Provisionally increment state version and create directory
1001 const std::string new_dir = state_dir(++_state_version);
1002 g_mkdir_with_parents(new_dir.c_str(), 0744);
1004 LilvState* state = lilv_state_new_from_instance(
1007 _uri_map.urid_map(),
1008 scratch_dir().c_str(),
1010 _session.externals_dir().c_str(),
1013 const_cast<LV2Plugin*>(this),
1017 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
1018 lilv_state_save(_world.world,
1019 _uri_map.urid_map(),
1020 _uri_map.urid_unmap(),
1026 lilv_state_free(_impl->state);
1027 _impl->state = state;
1029 // State is identical, decrement version and nuke directory
1030 lilv_state_free(state);
1031 PBD::remove_directory(new_dir);
1035 root->add_property("state-dir", string_compose("state%1", _state_version));
1039 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1041 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1043 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1045 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1046 lilv_nodes_free(vs);
1053 LV2Plugin::find_presets()
1055 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1056 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1057 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1059 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1060 LILV_FOREACH(nodes, i, presets) {
1061 const LilvNode* preset = lilv_nodes_get(presets, i);
1062 lilv_world_load_resource(_world.world, preset);
1063 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1065 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1066 Plugin::PresetRecord(
1067 lilv_node_as_string(preset),
1068 lilv_node_as_string(name))));
1069 lilv_node_free(name);
1071 warning << string_compose(
1072 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1073 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1074 lilv_node_as_string(preset)) << endmsg;
1077 lilv_nodes_free(presets);
1079 lilv_node_free(rdfs_label);
1080 lilv_node_free(pset_Preset);
1081 lilv_node_free(lv2_appliesTo);
1085 set_port_value(const char* port_symbol,
1091 LV2Plugin* self = (LV2Plugin*)user_data;
1092 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1093 return; // TODO: Support non-float ports
1096 const uint32_t port_index = self->port_index(port_symbol);
1097 if (port_index != (uint32_t)-1) {
1098 self->set_parameter(port_index, *(const float*)value);
1103 LV2Plugin::load_preset(PresetRecord r)
1105 LilvWorld* world = _world.world;
1106 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1107 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1110 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1111 lilv_state_free(state);
1112 Plugin::load_preset(r);
1115 lilv_node_free(pset);
1120 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1125 LV2Plugin *plugin = (LV2Plugin *) user_data;
1127 uint32_t index = plugin->port_index(port_symbol);
1128 if (index != (uint32_t) -1) {
1129 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1131 *size = sizeof(float);
1132 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1133 value = &plugin->_shadow_data[index];
1145 LV2Plugin::do_save_preset(string name)
1147 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1148 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1149 const string base_name = legalize_for_uri(name);
1150 const string file_name = base_name + ".ttl";
1151 const string bundle = Glib::build_filename(
1152 Glib::get_home_dir(),
1153 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1155 #ifdef HAVE_LILV_0_21_3
1156 /* delete reference to old preset (if any) */
1157 const PresetRecord* r = preset_by_label(name);
1159 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1161 lilv_world_unload_resource (_world.world, pset);
1162 lilv_node_free(pset);
1167 LilvState* state = lilv_state_new_from_instance(
1170 _uri_map.urid_map(),
1171 scratch_dir().c_str(), // file_dir
1172 bundle.c_str(), // copy_dir
1173 bundle.c_str(), // link_dir
1174 bundle.c_str(), // save_dir
1175 lv2plugin_get_port_value, // get_value
1176 (void*)this, // user_data
1177 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1178 _features // features
1181 lilv_state_set_label(state, name.c_str());
1183 _world.world, // world
1184 _uri_map.urid_map(), // map
1185 _uri_map.urid_unmap(), // unmap
1187 NULL, // uri (NULL = use file URI)
1188 bundle.c_str(), // dir
1189 file_name.c_str() // filename
1192 lilv_state_free(state);
1194 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1195 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1196 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1197 #ifdef HAVE_LILV_0_21_3
1198 lilv_world_unload_resource(_world.world, node_preset);
1199 lilv_world_unload_bundle(_world.world, node_bundle);
1201 lilv_world_load_bundle(_world.world, node_bundle);
1202 lilv_world_load_resource(_world.world, node_preset);
1203 lilv_node_free(node_bundle);
1204 lilv_node_free(node_preset);
1205 lilv_node_free(plug_name);
1210 LV2Plugin::do_remove_preset(string name)
1212 #ifdef HAVE_LILV_0_21_3
1213 /* Look up preset record by label (FIXME: ick, label as ID) */
1214 const PresetRecord* r = preset_by_label(name);
1219 /* Load a LilvState for the preset. */
1220 LilvWorld* world = _world.world;
1221 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1222 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1224 lilv_node_free(pset);
1228 /* Unload preset from world. */
1229 lilv_world_unload_resource(world, pset);
1231 /* Delete it from the file system. This will remove the preset file and the entry
1232 from the manifest. If this results in an empty manifest (i.e. the
1233 preset is the only thing in the bundle), then the bundle is removed. */
1234 lilv_state_delete(world, state);
1236 lilv_state_free(state);
1237 lilv_node_free(pset);
1239 /* Without lilv_state_delete(), we could delete the preset file, but this
1240 would leave a broken bundle/manifest around, so the preset would still
1241 be visible, but broken. Naively deleting a bundle is too dangerous, so
1242 we simply do not support preset deletion with older Lilv */
1246 LV2Plugin::has_editor() const
1248 return _impl->ui != NULL;
1252 LV2Plugin::has_message_output() const
1254 for (uint32_t i = 0; i < num_ports(); ++i) {
1255 if ((_port_flags[i] & PORT_SEQUENCE) &&
1256 (_port_flags[i] & PORT_OUTPUT)) {
1264 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1268 const uint8_t* body)
1270 const uint32_t buf_size = sizeof(UIMessage) + size;
1271 vector<uint8_t> buf(buf_size);
1273 UIMessage* msg = (UIMessage*)&buf[0];
1275 msg->protocol = protocol;
1277 memcpy(msg + 1, body, size);
1279 return (dest->write(&buf[0], buf_size) == buf_size);
1283 LV2Plugin::write_from_ui(uint32_t index,
1286 const uint8_t* body)
1289 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1290 /* buffer data communication from plugin UI to plugin instance.
1291 * this buffer needs to potentially hold
1292 * (port's minimumSize) * (audio-periods) / (UI-periods)
1295 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1296 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1297 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1299 * it is NOT safe to overflow (msg.size will be misinterpreted)
1301 uint32_t bufsiz = 32768;
1302 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1303 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1305 rbs = max((size_t) bufsiz * 8, rbs);
1306 _from_ui = new RingBuffer<uint8_t>(rbs);
1309 if (!write_to(_from_ui, index, protocol, size, body)) {
1310 error << "Error writing from UI to plugin" << endmsg;
1317 LV2Plugin::write_to_ui(uint32_t index,
1320 const uint8_t* body)
1322 if (!write_to(_to_ui, index, protocol, size, body)) {
1323 error << "Error writing from plugin to UI" << endmsg;
1330 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1332 switch (value.type()) {
1333 case Variant::NOTHING:
1335 case Variant::BEATS:
1336 // No atom type for this, just forge a double
1337 lv2_atom_forge_double(forge, value.get_beats().to_double());
1340 lv2_atom_forge_bool(forge, value.get_bool());
1342 case Variant::DOUBLE:
1343 lv2_atom_forge_double(forge, value.get_double());
1345 case Variant::FLOAT:
1346 lv2_atom_forge_float(forge, value.get_float());
1349 lv2_atom_forge_int(forge, value.get_int());
1352 lv2_atom_forge_long(forge, value.get_long());
1355 lv2_atom_forge_path(
1356 forge, value.get_path().c_str(), value.get_path().size());
1358 case Variant::STRING:
1359 lv2_atom_forge_string(
1360 forge, value.get_string().c_str(), value.get_string().size());
1364 forge, value.get_uri().c_str(), value.get_uri().size());
1369 /** Get a variant type from a URI, return false iff no match found. */
1371 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1373 if (uri == LV2_ATOM__Bool) {
1374 type = Variant::BOOL;
1375 } else if (uri == LV2_ATOM__Double) {
1376 type = Variant::DOUBLE;
1377 } else if (uri == LV2_ATOM__Float) {
1378 type = Variant::FLOAT;
1379 } else if (uri == LV2_ATOM__Int) {
1380 type = Variant::INT;
1381 } else if (uri == LV2_ATOM__Long) {
1382 type = Variant::LONG;
1383 } else if (uri == LV2_ATOM__Path) {
1384 type = Variant::PATH;
1385 } else if (uri == LV2_ATOM__String) {
1386 type = Variant::STRING;
1387 } else if (uri == LV2_ATOM__URI) {
1388 type = Variant::URI;
1396 LV2Plugin::set_property(uint32_t key, const Variant& value)
1398 if (_patch_port_in_index == (uint32_t)-1) {
1399 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1401 } else if (value.type() == Variant::NOTHING) {
1402 error << "LV2: set_property called with void value" << endmsg;
1406 // Set up forge to write to temporary buffer on the stack
1407 LV2_Atom_Forge* forge = &_impl->ui_forge;
1408 LV2_Atom_Forge_Frame frame;
1409 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1411 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1413 // Serialize patch:Set message to set property
1414 #ifdef HAVE_LV2_1_10_0
1415 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1416 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1417 lv2_atom_forge_urid(forge, key);
1418 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1420 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1421 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1422 lv2_atom_forge_urid(forge, key);
1423 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1426 forge_variant(forge, value);
1428 // Write message to UI=>Plugin ring
1429 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1430 write_from_ui(_patch_port_in_index,
1431 _uri_map.urids.atom_eventTransfer,
1432 lv2_atom_total_size(atom),
1433 (const uint8_t*)atom);
1436 const ParameterDescriptor&
1437 LV2Plugin::get_property_descriptor(uint32_t id) const
1439 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1440 if (p != _property_descriptors.end()) {
1443 return Plugin::get_property_descriptor(id);
1447 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1449 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1450 desc.unit = ParameterDescriptor::MIDI_NOTE;
1451 } else if (lilv_nodes_contains(units, _world.units_db)) {
1452 desc.unit = ParameterDescriptor::DB;
1453 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1454 desc.unit = ParameterDescriptor::HZ;
1456 if (lilv_nodes_size(units) > 0) {
1457 const LilvNode* unit = lilv_nodes_get_first(units);
1458 LilvNode* render = get_value(lworld, unit, _world.units_render);
1460 desc.print_fmt = lilv_node_as_string(render);
1461 lilv_node_free(render);
1467 load_parameter_descriptor(LV2World& world,
1468 ParameterDescriptor& desc,
1469 Variant::Type datatype,
1470 const LilvNode* subject)
1472 LilvWorld* lworld = _world.world;
1473 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1474 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1475 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1476 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1477 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1479 desc.label = lilv_node_as_string(label);
1481 if (def && lilv_node_is_float(def)) {
1482 desc.normal = lilv_node_as_float(def);
1484 if (minimum && lilv_node_is_float(minimum)) {
1485 desc.lower = lilv_node_as_float(minimum);
1487 if (maximum && lilv_node_is_float(maximum)) {
1488 desc.upper = lilv_node_as_float(maximum);
1490 load_parameter_descriptor_units(lworld, desc, units);
1491 desc.datatype = datatype;
1492 desc.toggled |= datatype == Variant::BOOL;
1493 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1494 desc.update_steps();
1496 lilv_nodes_free(units);
1497 lilv_node_free(label);
1498 lilv_node_free(def);
1499 lilv_node_free(minimum);
1500 lilv_node_free(maximum);
1504 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1506 LilvWorld* lworld = _world.world;
1507 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1508 LilvNodes* properties = lilv_world_find_nodes(
1509 lworld, subject, _world.patch_writable, NULL);
1510 LILV_FOREACH(nodes, p, properties) {
1511 // Get label and range
1512 const LilvNode* prop = lilv_nodes_get(properties, p);
1513 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1515 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1516 lilv_node_as_uri(prop)) << endmsg;
1520 // Convert range to variant type (TODO: support for multiple range types)
1521 Variant::Type datatype;
1522 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1523 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1524 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1528 // Add description to result
1529 ParameterDescriptor desc;
1530 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1531 desc.datatype = datatype;
1532 load_parameter_descriptor(_world, desc, datatype, prop);
1533 descs.insert(std::make_pair(desc.key, desc));
1535 lilv_node_free(range);
1537 lilv_nodes_free(properties);
1541 LV2Plugin::announce_property_values()
1543 if (_patch_port_in_index == (uint32_t)-1) {
1547 // Set up forge to write to temporary buffer on the stack
1548 LV2_Atom_Forge* forge = &_impl->ui_forge;
1549 LV2_Atom_Forge_Frame frame;
1550 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1552 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1554 // Serialize patch:Get message with no subject (implicitly plugin instance)
1555 #ifdef HAVE_LV2_1_10_0
1556 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1558 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1561 // Write message to UI=>Plugin ring
1562 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1563 write_from_ui(_patch_port_in_index,
1564 _uri_map.urids.atom_eventTransfer,
1565 lv2_atom_total_size(atom),
1566 (const uint8_t*)atom);
1570 LV2Plugin::enable_ui_emission()
1573 /* see note in LV2Plugin::write_from_ui() */
1574 uint32_t bufsiz = 32768;
1575 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1576 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1578 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1579 rbs = max((size_t) bufsiz * 8, rbs);
1580 _to_ui = new RingBuffer<uint8_t>(rbs);
1585 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1591 uint32_t read_space = _to_ui->read_space();
1592 while (read_space > sizeof(UIMessage)) {
1594 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1595 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1598 vector<uint8_t> body(msg.size);
1599 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1600 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1604 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1606 read_space -= sizeof(msg) + msg.size;
1611 LV2Plugin::work(uint32_t size, const void* data)
1613 return _impl->work_iface->work(
1614 _impl->instance->lv2_handle, work_respond, this, size, data);
1618 LV2Plugin::work_response(uint32_t size, const void* data)
1620 return _impl->work_iface->work_response(
1621 _impl->instance->lv2_handle, size, data);
1625 LV2Plugin::set_insert_id(PBD::ID id)
1631 LV2Plugin::set_state(const XMLNode& node, int version)
1634 const XMLProperty* prop;
1635 XMLNodeConstIterator iter;
1640 LocaleGuard lg(X_("C"));
1642 if (node.name() != state_node_name()) {
1643 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1647 #ifndef NO_PLUGIN_STATE
1649 if (version < 3000) {
1650 nodes = node.children("port");
1652 nodes = node.children("Port");
1655 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1659 if ((prop = child->property("symbol")) != 0) {
1660 sym = prop->value().c_str();
1662 warning << _("LV2: port has no symbol, ignored") << endmsg;
1666 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1668 if (i != _port_indices.end()) {
1669 port_id = i->second;
1671 warning << _("LV2: port has unknown index, ignored") << endmsg;
1675 if ((prop = child->property("value")) != 0) {
1676 value = prop->value().c_str();
1678 warning << _("LV2: port has no value, ignored") << endmsg;
1682 set_parameter(port_id, atof(value));
1686 if ((prop = node.property("state-dir")) != 0) {
1687 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1688 error << string_compose(
1689 "LV2: failed to parse state version from \"%1\"",
1690 prop->value()) << endmsg;
1693 std::string state_file = Glib::build_filename(
1695 Glib::build_filename(prop->value(), "state.ttl"));
1697 LilvState* state = lilv_state_new_from_file(
1698 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1700 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1701 lilv_state_free(_impl->state);
1702 _impl->state = state;
1705 latency_compute_run();
1708 return Plugin::set_state(node, version);
1712 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1714 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1716 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1721 LilvNodes* portunits;
1722 LilvNode *def, *min, *max;
1723 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1724 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1726 // TODO: Once we can rely on lilv 0.18.0 being present,
1727 // load_parameter_descriptor() can be used for ports as well
1728 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1729 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1730 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1731 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1732 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1733 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1734 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1735 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1736 load_parameter_descriptor_units(_world.world, desc, portunits);
1738 if (desc.sr_dependent) {
1739 desc.lower *= _session.frame_rate ();
1740 desc.upper *= _session.frame_rate ();
1743 desc.min_unbound = false; // TODO: LV2 extension required
1744 desc.max_unbound = false; // TODO: LV2 extension required
1746 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1747 desc.scale_points = get_scale_points(which);
1749 desc.update_steps();
1751 lilv_node_free(def);
1752 lilv_node_free(min);
1753 lilv_node_free(max);
1754 lilv_nodes_free(portunits);
1760 LV2Plugin::describe_parameter(Evoral::Parameter which)
1762 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1764 if (lilv_port_has_property(_impl->plugin,
1765 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1766 return X_("hidden");
1769 if (lilv_port_has_property(_impl->plugin,
1770 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1771 return X_("hidden");
1774 if (lilv_port_has_property(_impl->plugin,
1775 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1776 return X_("latency");
1779 LilvNode* name = lilv_port_get_name(_impl->plugin,
1780 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1781 string ret(lilv_node_as_string(name));
1782 lilv_node_free(name);
1790 LV2Plugin::signal_latency() const
1792 if (_latency_control_port) {
1793 return (framecnt_t)floor(*_latency_control_port);
1799 set<Evoral::Parameter>
1800 LV2Plugin::automatable() const
1802 set<Evoral::Parameter> ret;
1804 for (uint32_t i = 0; i < parameter_count(); ++i) {
1805 if (parameter_is_input(i) && parameter_is_control(i)) {
1806 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1810 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1811 p != _property_descriptors.end();
1813 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1819 LV2Plugin::activate()
1821 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1823 if (!_was_activated) {
1824 lilv_instance_activate(_impl->instance);
1825 _was_activated = true;
1830 LV2Plugin::deactivate()
1832 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1834 if (_was_activated) {
1835 lilv_instance_deactivate(_impl->instance);
1836 _was_activated = false;
1841 LV2Plugin::cleanup()
1843 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1847 lilv_instance_free(_impl->instance);
1848 _impl->instance = NULL;
1852 LV2Plugin::allocate_atom_event_buffers()
1854 /* reserve local scratch buffers for ATOM event-queues */
1855 const LilvPlugin* p = _impl->plugin;
1857 /* count non-MIDI atom event-ports
1858 * TODO: nicely ask drobilla to make a lilv_ call for that
1860 int count_atom_out = 0;
1861 int count_atom_in = 0;
1862 int minimumSize = 32768; // TODO use a per-port minimum-size
1863 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1864 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1865 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1866 LilvNodes* buffer_types = lilv_port_get_value(
1867 p, port, _world.atom_bufferType);
1868 LilvNodes* atom_supports = lilv_port_get_value(
1869 p, port, _world.atom_supports);
1871 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1872 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1873 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1876 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1879 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1880 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1881 if (min_size && lilv_node_is_int(min_size)) {
1882 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1884 lilv_nodes_free(min_size_v);
1886 lilv_nodes_free(buffer_types);
1887 lilv_nodes_free(atom_supports);
1891 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1892 name(), count_atom_in, count_atom_out));
1894 const int total_atom_buffers = (count_atom_in + count_atom_out);
1895 if (_atom_ev_buffers || total_atom_buffers == 0) {
1899 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1900 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1901 for (int i = 0; i < total_atom_buffers; ++i ) {
1902 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1903 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1905 _atom_ev_buffers[total_atom_buffers] = 0;
1909 /** Write an ardour position/time/tempo/meter as an LV2 event.
1910 * @return true on success.
1913 write_position(LV2_Atom_Forge* forge,
1915 const TempoMetric& t,
1916 Timecode::BBT_Time& bbt,
1918 framepos_t position,
1921 const URIMap::URIDs& urids = URIMap::instance().urids;
1923 uint8_t pos_buf[256];
1924 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1925 LV2_Atom_Forge_Frame frame;
1926 #ifdef HAVE_LV2_1_10_0
1927 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1928 lv2_atom_forge_key(forge, urids.time_frame);
1929 lv2_atom_forge_long(forge, position);
1930 lv2_atom_forge_key(forge, urids.time_speed);
1931 lv2_atom_forge_float(forge, speed);
1932 lv2_atom_forge_key(forge, urids.time_barBeat);
1933 lv2_atom_forge_float(forge, bbt.beats - 1 +
1934 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1935 lv2_atom_forge_key(forge, urids.time_bar);
1936 lv2_atom_forge_long(forge, bbt.bars - 1);
1937 lv2_atom_forge_key(forge, urids.time_beatUnit);
1938 lv2_atom_forge_int(forge, t.meter().note_divisor());
1939 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1940 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1941 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1942 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1944 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1945 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1946 lv2_atom_forge_long(forge, position);
1947 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1948 lv2_atom_forge_float(forge, speed);
1949 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1950 lv2_atom_forge_float(forge, bbt.beats - 1 +
1951 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1952 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1953 lv2_atom_forge_long(forge, bbt.bars - 1);
1954 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1955 lv2_atom_forge_int(forge, t.meter().note_divisor());
1956 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1957 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1958 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1959 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1962 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
1963 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1964 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1965 (const uint8_t*)(atom + 1));
1969 LV2Plugin::connect_and_run(BufferSet& bufs,
1970 ChanMapping in_map, ChanMapping out_map,
1971 pframes_t nframes, framecnt_t offset)
1973 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1974 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1976 cycles_t then = get_cycles();
1978 TempoMap& tmap = _session.tempo_map();
1979 Metrics::const_iterator metric_i = tmap.metrics_end();
1980 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
1982 if (_freewheel_control_port) {
1983 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
1986 if (_bpm_control_port) {
1987 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1990 ChanCount bufs_count;
1991 bufs_count.set(DataType::AUDIO, 1);
1992 bufs_count.set(DataType::MIDI, 1);
1993 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
1994 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1995 uint32_t const num_ports = parameter_count();
1996 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1998 uint32_t audio_in_index = 0;
1999 uint32_t audio_out_index = 0;
2000 uint32_t midi_in_index = 0;
2001 uint32_t midi_out_index = 0;
2002 uint32_t atom_port_index = 0;
2003 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2005 uint32_t index = nil_index;
2006 PortFlags flags = _port_flags[port_index];
2008 if (flags & PORT_AUDIO) {
2009 if (flags & PORT_INPUT) {
2010 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2012 ? bufs.get_audio(index).data(offset)
2013 : silent_bufs.get_audio(0).data(offset);
2015 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2017 ? bufs.get_audio(index).data(offset)
2018 : scratch_bufs.get_audio(0).data(offset);
2020 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2021 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2022 be necessary, but the mapping is illegal in some cases. Ideally
2023 that should be fixed, but this is easier...
2025 if (flags & PORT_MIDI) {
2026 if (flags & PORT_INPUT) {
2027 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2029 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2031 if (valid && bufs.count().n_midi() > index) {
2032 /* Note, ensure_lv2_bufsize() is not RT safe!
2033 * However free()/alloc() is only called if a
2034 * plugin requires a rsz:minimumSize buffersize
2035 * and the existing buffer if smaller.
2037 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2038 _ev_buffers[port_index] = bufs.get_lv2_midi(
2039 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2041 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2042 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2043 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2047 if (valid && (flags & PORT_INPUT)) {
2048 Timecode::BBT_Time bbt;
2049 if ((flags & PORT_POSITION)) {
2050 if (_session.transport_frame() != _next_cycle_start ||
2051 _session.transport_speed() != _next_cycle_speed) {
2052 // Transport has changed, write position at cycle start
2053 tmap.bbt_time(_session.transport_frame(), bbt);
2054 write_position(&_impl->forge, _ev_buffers[port_index],
2055 tmetric, bbt, _session.transport_speed(),
2056 _session.transport_frame(), 0);
2060 // Get MIDI iterator range (empty range if no MIDI)
2061 MidiBuffer::iterator m = (index != nil_index)
2062 ? bufs.get_midi(index).begin()
2063 : silent_bufs.get_midi(0).end();
2064 MidiBuffer::iterator m_end = (index != nil_index)
2065 ? bufs.get_midi(index).end()
2068 // Now merge MIDI and any transport events into the buffer
2069 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2070 const framepos_t tend = _session.transport_frame() + nframes;
2072 while (m != m_end || (metric_i != tmap.metrics_end() &&
2073 (*metric_i)->frame() < tend)) {
2074 MetricSection* metric = (metric_i != tmap.metrics_end())
2076 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2077 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2078 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2079 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2082 tmetric.set_metric(metric);
2083 bbt = metric->start();
2084 write_position(&_impl->forge, _ev_buffers[port_index],
2085 tmetric, bbt, _session.transport_speed(),
2087 metric->frame() - _session.transport_frame());
2091 } else if (!valid) {
2092 // Nothing we understand or care about, connect to scratch
2093 // see note for midi-buffer size above
2094 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2095 0, _port_minimumSize[port_index]);
2096 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2097 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2100 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2102 continue; // Control port, leave buffer alone
2104 lilv_instance_connect_port(_impl->instance, port_index, buf);
2107 // Read messages from UI and push into appropriate buffers
2109 uint32_t read_space = _from_ui->read_space();
2110 while (read_space > sizeof(UIMessage)) {
2112 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2113 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2116 vector<uint8_t> body(msg.size);
2117 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2118 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2121 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2122 LV2_Evbuf* buf = _ev_buffers[msg.index];
2123 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2124 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2125 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2126 (const uint8_t*)(atom + 1))) {
2127 error << "Failed to write data to LV2 event buffer\n";
2130 error << "Received unknown message type from UI" << endmsg;
2132 read_space -= sizeof(UIMessage) + msg.size;
2139 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2140 PortFlags flags = _port_flags[port_index];
2143 /* TODO ask drobilla about comment
2144 * "Make Ardour event buffers generic so plugins can communicate"
2145 * in libs/ardour/buffer_set.cc:310
2147 * ideally the user could choose which of the following two modes
2148 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2150 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2151 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2152 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2153 * for quite a while at least ;)
2155 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2156 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2157 const uint32_t buf_index = out_map.get(
2158 DataType::MIDI, midi_out_index++, &valid);
2160 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2163 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2164 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2165 const uint32_t buf_index = out_map.get(
2166 DataType::MIDI, midi_out_index++, &valid);
2168 bufs.flush_lv2_midi(true, buf_index);
2173 // Write messages to UI
2174 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2175 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2176 LV2_Evbuf* buf = _ev_buffers[port_index];
2177 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2178 lv2_evbuf_is_valid(i);
2179 i = lv2_evbuf_next(i)) {
2180 uint32_t frames, subframes, type, size;
2182 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2184 // Intercept patch change messages to emit PropertyChanged signal
2185 if ((flags & PORT_PATCHMSG)) {
2186 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2187 if (atom->type == _uri_map.urids.atom_Blank ||
2188 atom->type == _uri_map.urids.atom_Object) {
2189 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2190 if (obj->body.otype == _uri_map.urids.patch_Set) {
2191 const LV2_Atom* property = NULL;
2192 const LV2_Atom* value = NULL;
2193 lv2_atom_object_get(obj,
2194 _uri_map.urids.patch_property, &property,
2195 _uri_map.urids.patch_value, &value,
2198 if (!property || !value ||
2199 property->type != _uri_map.urids.atom_URID ||
2200 value->type != _uri_map.urids.atom_Path) {
2201 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2205 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2206 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2208 // Emit PropertyChanged signal for UI
2209 // TODO: This should emit the control's Changed signal
2210 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2215 if (!_to_ui) continue;
2216 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2217 size + sizeof(LV2_Atom),
2218 data - sizeof(LV2_Atom));
2223 cycles_t now = get_cycles();
2224 set_cycles((uint32_t)(now - then));
2226 // Update expected transport information for next cycle so we can detect changes
2227 _next_cycle_speed = _session.transport_speed();
2228 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2234 LV2Plugin::parameter_is_control(uint32_t param) const
2236 assert(param < _port_flags.size());
2237 return _port_flags[param] & PORT_CONTROL;
2241 LV2Plugin::parameter_is_audio(uint32_t param) const
2243 assert(param < _port_flags.size());
2244 return _port_flags[param] & PORT_AUDIO;
2248 LV2Plugin::parameter_is_event(uint32_t param) const
2250 assert(param < _port_flags.size());
2251 return _port_flags[param] & PORT_EVENT;
2255 LV2Plugin::parameter_is_output(uint32_t param) const
2257 assert(param < _port_flags.size());
2258 return _port_flags[param] & PORT_OUTPUT;
2262 LV2Plugin::parameter_is_input(uint32_t param) const
2264 assert(param < _port_flags.size());
2265 return _port_flags[param] & PORT_INPUT;
2269 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2272 if (param < parameter_count()) {
2273 snprintf(buf, len, "%.3f", get_parameter(param));
2280 boost::shared_ptr<ScalePoints>
2281 LV2Plugin::get_scale_points(uint32_t port_index) const
2283 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2284 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2286 boost::shared_ptr<ScalePoints> ret;
2291 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2293 LILV_FOREACH(scale_points, i, points) {
2294 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2295 const LilvNode* label = lilv_scale_point_get_label(p);
2296 const LilvNode* value = lilv_scale_point_get_value(p);
2297 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2298 ret->insert(make_pair(lilv_node_as_string(label),
2299 lilv_node_as_float(value)));
2303 lilv_scale_points_free(points);
2308 LV2Plugin::run(pframes_t nframes)
2310 uint32_t const N = parameter_count();
2311 for (uint32_t i = 0; i < N; ++i) {
2312 if (parameter_is_control(i) && parameter_is_input(i)) {
2313 _control_data[i] = _shadow_data[i];
2317 lilv_instance_run(_impl->instance, nframes);
2319 if (_impl->work_iface) {
2320 _worker->emit_responses();
2321 if (_impl->work_iface->end_run) {
2322 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2328 LV2Plugin::latency_compute_run()
2330 if (!_latency_control_port) {
2334 // Run the plugin so that it can set its latency parameter
2336 bool was_activated = _was_activated;
2339 uint32_t port_index = 0;
2340 uint32_t in_index = 0;
2341 uint32_t out_index = 0;
2343 // this is done in the main thread. non realtime.
2344 const framecnt_t bufsize = _engine.samples_per_cycle();
2345 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2347 memset(buffer, 0, sizeof(float) * bufsize);
2349 // FIXME: Ensure plugins can handle in-place processing
2353 while (port_index < parameter_count()) {
2354 if (parameter_is_audio(port_index)) {
2355 if (parameter_is_input(port_index)) {
2356 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2358 } else if (parameter_is_output(port_index)) {
2359 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2368 if (was_activated) {
2375 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2377 const LilvPort* port = NULL;
2378 LilvNode* designation = lilv_new_uri(_world.world, uri);
2379 port = lilv_plugin_get_port_by_designation(
2380 plugin, _world.lv2_InputPort, designation);
2381 lilv_node_free(designation);
2383 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2388 static bool lv2_filter (const string& str, void* /*arg*/)
2390 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2392 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2396 LV2World::LV2World()
2397 : world(lilv_world_new())
2398 , _bundle_checked(false)
2400 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2401 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2402 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2403 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2404 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2405 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2406 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2407 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2408 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2409 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2410 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2411 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2412 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2413 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2414 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2415 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2416 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2417 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2418 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2419 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2420 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2421 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2422 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2423 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2424 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2425 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2426 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2427 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2428 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2429 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2430 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2431 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2432 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2433 units_render = lilv_new_uri(world, LV2_UNITS__render);
2434 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2435 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2436 units_db = lilv_new_uri(world, LV2_UNITS__db);
2437 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2438 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2439 #ifdef HAVE_LV2_1_2_0
2440 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2441 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2442 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2447 LV2World::~LV2World()
2449 #ifdef HAVE_LV2_1_2_0
2450 lilv_node_free(bufz_nominalBlockLength);
2451 lilv_node_free(bufz_fixedBlockLength);
2452 lilv_node_free(bufz_powerOf2BlockLength);
2454 lilv_node_free(patch_Message);
2455 lilv_node_free(patch_writable);
2456 lilv_node_free(units_hz);
2457 lilv_node_free(units_midiNote);
2458 lilv_node_free(units_db);
2459 lilv_node_free(units_unit);
2460 lilv_node_free(units_render);
2461 lilv_node_free(ui_externalkx);
2462 lilv_node_free(ui_external);
2463 lilv_node_free(ui_GtkUI);
2464 lilv_node_free(time_Position);
2465 lilv_node_free(rsz_minimumSize);
2466 lilv_node_free(rdfs_comment);
2467 lilv_node_free(rdfs_label);
2468 lilv_node_free(rdfs_range);
2469 lilv_node_free(midi_MidiEvent);
2470 lilv_node_free(lv2_enumeration);
2471 lilv_node_free(lv2_freewheeling);
2472 lilv_node_free(lv2_toggled);
2473 lilv_node_free(lv2_sampleRate);
2474 lilv_node_free(lv2_reportsLatency);
2475 lilv_node_free(lv2_integer);
2476 lilv_node_free(lv2_inPlaceBroken);
2477 lilv_node_free(lv2_OutputPort);
2478 lilv_node_free(lv2_InputPort);
2479 lilv_node_free(lv2_ControlPort);
2480 lilv_node_free(lv2_AudioPort);
2481 lilv_node_free(ext_notOnGUI);
2482 lilv_node_free(ext_logarithmic);
2483 lilv_node_free(ev_EventPort);
2484 lilv_node_free(atom_supports);
2485 lilv_node_free(atom_eventTransfer);
2486 lilv_node_free(atom_bufferType);
2487 lilv_node_free(atom_Sequence);
2488 lilv_node_free(atom_Chunk);
2489 lilv_node_free(atom_AtomPort);
2490 lilv_world_free(world);
2494 LV2World::load_bundled_plugins(bool verbose)
2496 if (!_bundle_checked) {
2498 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2501 vector<string> plugin_objects;
2502 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2503 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2504 #ifdef PLATFORM_WINDOWS
2505 string uri = "file:///" + *x + "/";
2507 string uri = "file://" + *x + "/";
2509 LilvNode *node = lilv_new_uri(world, uri.c_str());
2510 lilv_world_load_bundle(world, node);
2511 lilv_node_free(node);
2514 lilv_world_load_all(world);
2515 _bundle_checked = true;
2519 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2522 _plugin_uri = strdup(plugin_uri);
2525 LV2PluginInfo::~LV2PluginInfo()
2532 LV2PluginInfo::load(Session& session)
2536 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2537 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2538 if (!uri) { throw failed_constructor(); }
2539 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2540 if (!lp) { throw failed_constructor(); }
2541 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2542 lilv_node_free(uri);
2543 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2545 } catch (failed_constructor& err) {
2546 return PluginPtr((Plugin*)0);
2553 LV2PluginInfo::discover()
2556 world.load_bundled_plugins();
2557 _world.load_bundled_plugins(true);
2559 PluginInfoList* plugs = new PluginInfoList;
2560 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2562 LILV_FOREACH(plugins, i, plugins) {
2563 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2564 const LilvNode* pun = lilv_plugin_get_uri(p);
2566 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2568 LilvNode* name = lilv_plugin_get_name(p);
2569 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2570 warning << "Ignoring invalid LV2 plugin "
2571 << lilv_node_as_string(lilv_plugin_get_uri(p))
2576 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2577 warning << string_compose(
2578 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2579 lilv_node_as_string(name)) << endmsg;
2580 lilv_node_free(name);
2584 #ifdef HAVE_LV2_1_2_0
2585 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2586 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2587 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2589 warning << string_compose(
2590 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2591 lilv_node_as_string(name)) << endmsg;
2592 lilv_nodes_free(required_features);
2593 lilv_node_free(name);
2596 lilv_nodes_free(required_features);
2601 info->name = string(lilv_node_as_string(name));
2602 lilv_node_free(name);
2603 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2605 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2606 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2607 info->category = lilv_node_as_string(label);
2609 LilvNode* author_name = lilv_plugin_get_author_name(p);
2610 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2611 lilv_node_free(author_name);
2613 info->path = "/NOPATH"; // Meaningless for LV2
2615 /* count atom-event-ports that feature
2616 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2618 * TODO: nicely ask drobilla to make a lilv_ call for that
2620 int count_midi_out = 0;
2621 int count_midi_in = 0;
2622 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2623 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2624 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2625 LilvNodes* buffer_types = lilv_port_get_value(
2626 p, port, world.atom_bufferType);
2627 LilvNodes* atom_supports = lilv_port_get_value(
2628 p, port, world.atom_supports);
2630 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2631 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2632 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2635 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2639 lilv_nodes_free(buffer_types);
2640 lilv_nodes_free(atom_supports);
2644 info->n_inputs.set_audio(
2645 lilv_plugin_get_num_ports_of_class(
2646 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2647 info->n_inputs.set_midi(
2648 lilv_plugin_get_num_ports_of_class(
2649 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2652 info->n_outputs.set_audio(
2653 lilv_plugin_get_num_ports_of_class(
2654 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2655 info->n_outputs.set_midi(
2656 lilv_plugin_get_num_ports_of_class(
2657 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2660 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2661 info->index = 0; // Meaningless for LV2
2663 plugs->push_back(info);