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.
29 #include "pbd/gstdio_compat.h"
30 #include <glib/gprintf.h>
33 #include <boost/utility.hpp>
35 #include "pbd/file_utils.h"
36 #include "pbd/stl_delete.h"
37 #include "pbd/compose.h"
38 #include "pbd/error.h"
39 #include "pbd/xml++.h"
41 #include "libardour-config.h"
43 #include "ardour/audio_buffer.h"
44 #include "ardour/audioengine.h"
45 #include "ardour/debug.h"
46 #include "ardour/lv2_plugin.h"
47 #include "ardour/session.h"
48 #include "ardour/tempo.h"
49 #include "ardour/types.h"
50 #include "ardour/utils.h"
51 #include "ardour/worker.h"
52 #include "ardour/search_paths.h"
57 #include <lilv/lilv.h>
59 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
60 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
61 #include "lv2/lv2plug.in/ns/ext/log/log.h"
62 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
63 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
64 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
65 #include "lv2/lv2plug.in/ns/ext/state/state.h"
66 #include "lv2/lv2plug.in/ns/ext/time/time.h"
67 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
68 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
69 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
70 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
71 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
73 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
74 #include "lv2/lv2plug.in/ns/ext/options/options.h"
77 #include "lv2_evbuf.h"
80 #include <suil/suil.h>
83 // Compatibility for old LV2
84 #ifndef LV2_ATOM_CONTENTS_CONST
85 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
86 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
88 #ifndef LV2_ATOM_BODY_CONST
89 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
91 #ifndef LV2_PATCH__property
92 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
94 #ifndef LV2_PATCH__value
95 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
97 #ifndef LV2_PATCH__writable
98 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
101 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
102 This needs to be roughly the number of cycles the UI will get around to
103 actually processing the traffic. Lower values are flakier but save memory.
105 static const size_t NBUFS = 4;
108 using namespace ARDOUR;
111 class LV2World : boost::noncopyable {
116 void load_bundled_plugins(bool verbose=false);
120 LilvNode* atom_AtomPort;
121 LilvNode* atom_Chunk;
122 LilvNode* atom_Sequence;
123 LilvNode* atom_bufferType;
124 LilvNode* atom_eventTransfer;
125 LilvNode* atom_supports;
126 LilvNode* ev_EventPort;
127 LilvNode* ext_logarithmic;
128 LilvNode* ext_notOnGUI;
129 LilvNode* lv2_AudioPort;
130 LilvNode* lv2_ControlPort;
131 LilvNode* lv2_InputPort;
132 LilvNode* lv2_OutputPort;
133 LilvNode* lv2_enumeration;
134 LilvNode* lv2_freewheeling;
135 LilvNode* lv2_inPlaceBroken;
136 LilvNode* lv2_isSideChain;
137 LilvNode* lv2_integer;
138 LilvNode* lv2_default;
139 LilvNode* lv2_minimum;
140 LilvNode* lv2_maximum;
141 LilvNode* lv2_reportsLatency;
142 LilvNode* lv2_sampleRate;
143 LilvNode* lv2_toggled;
144 LilvNode* midi_MidiEvent;
145 LilvNode* rdfs_comment;
146 LilvNode* rdfs_label;
147 LilvNode* rdfs_range;
148 LilvNode* rsz_minimumSize;
149 LilvNode* time_Position;
151 LilvNode* ui_external;
152 LilvNode* ui_externalkx;
155 LilvNode* units_unit;
156 LilvNode* units_render;
157 LilvNode* units_midiNote;
158 LilvNode* patch_writable;
159 LilvNode* patch_Message;
160 #ifdef HAVE_LV2_1_2_0
161 LilvNode* bufz_powerOf2BlockLength;
162 LilvNode* bufz_fixedBlockLength;
163 LilvNode* bufz_nominalBlockLength;
166 #ifdef HAVE_LV2_1_10_0
168 LilvNode* atom_float;
169 LilvNode* atom_object; // new in 1.8
170 LilvNode* atom_vector;
173 LilvNode* lv2_noSampleAccurateCtrl;
174 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
175 LilvNode* auto_automation_control; // atom:supports
176 LilvNode* auto_automation_controlled; // lv2:portProperty
180 bool _bundle_checked;
183 static LV2World _world;
185 /* worker extension */
187 /** Called by the plugin to schedule non-RT work. */
188 static LV2_Worker_Status
189 work_schedule(LV2_Worker_Schedule_Handle handle,
193 LV2Plugin* plugin = (LV2Plugin*)handle;
194 if (plugin->session().engine().freewheeling()) {
195 // Freewheeling, do the work immediately in this (audio) thread
196 return (LV2_Worker_Status)plugin->work(size, data);
198 // Enqueue message for the worker thread
199 return plugin->worker()->schedule(size, data) ?
200 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
204 /** Called by the plugin to respond to non-RT work. */
205 static LV2_Worker_Status
206 work_respond(LV2_Worker_Respond_Handle handle,
210 LV2Plugin* plugin = (LV2Plugin*)handle;
211 if (plugin->session().engine().freewheeling()) {
212 // Freewheeling, respond immediately in this (audio) thread
213 return (LV2_Worker_Status)plugin->work_response(size, data);
215 // Enqueue response for the worker
216 return plugin->worker()->respond(size, data) ?
217 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
222 /* inline display extension */
224 queue_draw (LV2_Inline_Display_Handle handle)
226 LV2Plugin* plugin = (LV2Plugin*)handle;
227 plugin->QueueDraw(); /* EMIT SIGNAL */
234 log_vprintf(LV2_Log_Handle /*handle*/,
240 const int ret = g_vasprintf(&str, fmt, args);
241 /* strip trailing whitespace */
242 while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
243 str[strlen (str) - 1] = '\0';
245 if (strlen (str) == 0) {
249 if (type == URIMap::instance().urids.log_Error) {
250 error << str << endmsg;
251 } else if (type == URIMap::instance().urids.log_Warning) {
252 warning << str << endmsg;
253 } else if (type == URIMap::instance().urids.log_Note) {
254 info << str << endmsg;
256 // TODO: Toggleable log:Trace message support
261 log_printf(LV2_Log_Handle handle,
263 const char* fmt, ...)
267 const int ret = log_vprintf(handle, type, fmt, args);
272 struct LV2Plugin::Impl {
273 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
275 #ifdef HAVE_LV2_1_2_0
280 #ifdef HAVE_LV2_1_2_0
288 /** Find the LV2 input port with the given designation.
289 * If found, bufptrs[port_index] will be set to bufptr.
291 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
293 const LilvPlugin* plugin;
295 const LilvNode* ui_type;
298 LilvInstance* instance;
299 const LV2_Worker_Interface* work_iface;
300 #ifdef HAVE_LV2_1_2_0
301 const LV2_Options_Interface* opts_iface;
304 LV2_Atom_Forge forge;
305 LV2_Atom_Forge ui_forge;
306 int32_t block_length;
307 #ifdef HAVE_LV2_1_2_0
308 LV2_Options_Option* options;
311 LV2_Inline_Display* queue_draw;
315 LV2Plugin::LV2Plugin (AudioEngine& engine,
317 const void* c_plugin,
319 : Plugin (engine, session)
325 , _patch_port_in_index((uint32_t)-1)
326 , _patch_port_out_index((uint32_t)-1)
327 , _uri_map(URIMap::instance())
328 , _no_sample_accurate_ctrl (false)
330 init(c_plugin, rate);
333 LV2Plugin::LV2Plugin (const LV2Plugin& other)
339 , _insert_id(other._insert_id)
340 , _patch_port_in_index((uint32_t)-1)
341 , _patch_port_out_index((uint32_t)-1)
342 , _uri_map(URIMap::instance())
343 , _no_sample_accurate_ctrl (false)
345 init(other._impl->plugin, other._sample_rate);
347 for (uint32_t i = 0; i < parameter_count(); ++i) {
348 _control_data[i] = other._shadow_data[i];
349 _shadow_data[i] = other._shadow_data[i];
354 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
356 DEBUG_TRACE(DEBUG::LV2, "init\n");
358 _impl->plugin = (const LilvPlugin*)c_plugin;
360 _impl->ui_type = NULL;
365 _atom_ev_buffers = 0;
367 _bpm_control_port = 0;
368 _freewheel_control_port = 0;
369 _latency_control_port = 0;
370 _next_cycle_start = std::numeric_limits<framepos_t>::max();
371 _next_cycle_speed = 1.0;
372 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
374 _was_activated = false;
375 _has_state_interface = false;
376 _can_write_automation = false;
378 _current_latency = 0;
379 _impl->block_length = _session.get_block_size();
381 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
382 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
383 _make_path_feature.URI = LV2_STATE__makePath;
384 _log_feature.URI = LV2_LOG__log;
385 _work_schedule_feature.URI = LV2_WORKER__schedule;
386 _work_schedule_feature.data = NULL;
387 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
388 _def_state_feature.data = NULL;
390 const LilvPlugin* plugin = _impl->plugin;
392 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
393 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
394 _has_state_interface =
395 // What plugins should have (lv2:extensionData state:Interface)
396 lilv_plugin_has_extension_data(plugin, state_iface_uri)
397 // What some outdated/incorrect ones have
398 || lilv_plugin_has_feature(plugin, state_uri);
399 lilv_node_free(state_uri);
400 lilv_node_free(state_iface_uri);
402 _features = (LV2_Feature**)calloc(12, sizeof(LV2_Feature*));
403 _features[0] = &_instance_access_feature;
404 _features[1] = &_data_access_feature;
405 _features[2] = &_make_path_feature;
406 _features[3] = _uri_map.uri_map_feature();
407 _features[4] = _uri_map.urid_map_feature();
408 _features[5] = _uri_map.urid_unmap_feature();
409 _features[6] = &_log_feature;
411 unsigned n_features = 7;
412 #ifdef HAVE_LV2_1_2_0
413 _features[n_features++] = &_def_state_feature;
416 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
417 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
420 _impl->queue_draw = (LV2_Inline_Display*)
421 malloc (sizeof(LV2_Inline_Display));
422 _impl->queue_draw->handle = this;
423 _impl->queue_draw->queue_draw = queue_draw;
425 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
426 _queue_draw_feature.data = _impl->queue_draw;
427 _features[n_features++] = &_queue_draw_feature;
430 #ifdef HAVE_LV2_1_2_0
431 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
432 static const int32_t _min_block_length = 1; // may happen during split-cycles
433 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
434 /* Consider updating max-block-size whenever the buffersize changes.
435 * It requires re-instantiating the plugin (which is a non-realtime operation),
436 * so it should be done lightly and only for plugins that require it.
438 * given that the block-size can change at any time (split-cycles) ardour currently
439 * does not support plugins that require bufz_fixedBlockLength.
441 LV2_Options_Option options[] = {
442 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
443 sizeof(int32_t), atom_Int, &_min_block_length },
444 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
445 sizeof(int32_t), atom_Int, &_max_block_length },
446 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
447 sizeof(int32_t), atom_Int, &_seq_size },
448 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
449 sizeof(int32_t), atom_Int, &_impl->block_length },
450 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
453 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
454 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
456 _options_feature.URI = LV2_OPTIONS__options;
457 _options_feature.data = _impl->options;
458 _features[n_features++] = &_options_feature;
461 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
462 sizeof(LV2_State_Make_Path));
463 make_path->handle = this;
464 make_path->path = &lv2_state_make_path;
465 _make_path_feature.data = make_path;
467 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
469 log->printf = &log_printf;
470 log->vprintf = &log_vprintf;
471 _log_feature.data = log;
473 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
474 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
475 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
476 sizeof(LV2_Worker_Schedule));
477 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
478 _worker = new Worker(this, buf_size);
479 schedule->handle = this;
480 schedule->schedule_work = work_schedule;
481 _work_schedule_feature.data = schedule;
482 _features[n_features++] = &_work_schedule_feature;
484 lilv_node_free(worker_schedule);
486 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
487 _impl->name = lilv_plugin_get_name(plugin);
488 _impl->author = lilv_plugin_get_author_name(plugin);
490 if (_impl->instance == 0) {
491 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
492 throw failed_constructor();
495 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
496 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
497 _data_access_feature.data = &_data_access_extension_data;
499 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
500 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
501 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
502 LV2_WORKER__interface);
504 lilv_node_free(worker_iface_uri);
507 #ifdef HAVE_LV2_1_2_0
508 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
509 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
510 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
511 LV2_OPTIONS__interface);
513 lilv_node_free(options_iface_uri);
517 _display_interface = (const LV2_Inline_Display_Interface*)
518 extension_data (LV2_INLINEDISPLAY__interface);
521 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
522 error << string_compose(
523 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
524 lilv_node_as_string(_impl->name)) << endmsg;
525 lilv_node_free(_impl->name);
526 lilv_node_free(_impl->author);
527 throw failed_constructor();
530 #ifdef HAVE_LV2_1_2_0
531 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
532 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
533 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
535 error << string_compose(
536 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
537 lilv_node_as_string(_impl->name)) << endmsg;
538 lilv_node_free(_impl->name);
539 lilv_node_free(_impl->author);
540 lilv_nodes_free(required_features);
541 throw failed_constructor();
543 lilv_nodes_free(required_features);
547 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
548 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
549 _no_sample_accurate_ctrl = true;
551 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
552 _can_write_automation = true;
554 lilv_nodes_free(optional_features);
557 #ifdef HAVE_LILV_0_16_0
558 // Load default state
559 LilvState* state = lilv_state_new_from_world(
560 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
561 if (state && _has_state_interface) {
562 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
564 lilv_state_free(state);
569 const uint32_t num_ports = this->num_ports();
570 for (uint32_t i = 0; i < num_ports; ++i) {
571 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
573 size_t minimumSize = 0;
575 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
576 flags |= PORT_OUTPUT;
577 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
580 error << string_compose(
581 "LV2: \"%1\" port %2 is neither input nor output",
582 lilv_node_as_string(_impl->name), i) << endmsg;
583 throw failed_constructor();
586 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
587 flags |= PORT_CONTROL;
588 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
590 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
592 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
593 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
594 LilvNodes* buffer_types = lilv_port_get_value(
595 _impl->plugin, port, _world.atom_bufferType);
596 LilvNodes* atom_supports = lilv_port_get_value(
597 _impl->plugin, port, _world.atom_supports);
599 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
600 flags |= PORT_SEQUENCE;
601 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
604 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
605 flags |= PORT_POSITION;
608 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
609 flags |= PORT_AUTOCTRL;
612 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
613 flags |= PORT_PATCHMSG;
614 if (flags & PORT_INPUT) {
615 _patch_port_in_index = i;
617 _patch_port_out_index = i;
621 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
622 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
623 if (min_size && lilv_node_is_int(min_size)) {
624 minimumSize = lilv_node_as_int(min_size);
626 lilv_nodes_free(min_size_v);
627 lilv_nodes_free(buffer_types);
628 lilv_nodes_free(atom_supports);
630 error << string_compose(
631 "LV2: \"%1\" port %2 has no known data type",
632 lilv_node_as_string(_impl->name), i) << endmsg;
633 throw failed_constructor();
637 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
638 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
639 flags |= PORT_CTRLED;
644 _port_flags.push_back(flags);
645 _port_minimumSize.push_back(minimumSize);
646 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
649 _control_data = new float[num_ports];
650 _shadow_data = new float[num_ports];
651 _defaults = new float[num_ports];
652 _ev_buffers = new LV2_Evbuf*[num_ports];
653 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
655 const bool latent = lilv_plugin_has_latency(plugin);
656 const uint32_t latency_index = (latent)
657 ? lilv_plugin_get_latency_port_index(plugin)
660 // Build an array of pointers to special parameter buffers
661 void*** params = new void**[num_ports];
662 for (uint32_t i = 0; i < num_ports; ++i) {
665 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
666 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
668 for (uint32_t i = 0; i < num_ports; ++i) {
669 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
670 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
672 // Store index in map so we can look up index by symbol
673 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
675 // Get range and default value if applicable
676 if (parameter_is_control(i)) {
678 lilv_port_get_range(plugin, port, &def, NULL, NULL);
679 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
680 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
681 _defaults[i] *= _session.frame_rate ();
685 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
687 if (latent && i == latency_index) {
689 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
690 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
691 _latency_control_port = &_control_data[i];
692 *_latency_control_port = 0;
695 if (parameter_is_input(i)) {
696 _shadow_data[i] = default_value(i);
698 *params[i] = (void*)&_shadow_data[i];
708 LilvUIs* uis = lilv_plugin_get_uis(plugin);
709 if (lilv_uis_size(uis) > 0) {
711 // Look for embeddable UI
712 LILV_FOREACH(uis, u, uis) {
713 const LilvUI* this_ui = lilv_uis_get(uis, u);
714 const LilvNode* this_ui_type = NULL;
715 if (lilv_ui_is_supported(this_ui,
719 // TODO: Multiple UI support
721 _impl->ui_type = this_ui_type;
726 // Look for Gtk native UI
727 LILV_FOREACH(uis, i, uis) {
728 const LilvUI* ui = lilv_uis_get(uis, i);
729 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
731 _impl->ui_type = _world.ui_GtkUI;
737 // If Gtk UI is not available, try to find external UI
739 LILV_FOREACH(uis, i, uis) {
740 const LilvUI* ui = lilv_uis_get(uis, i);
741 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
743 _impl->ui_type = _world.ui_external;
746 if (lilv_ui_is_a(ui, _world.ui_external)) {
748 _impl->ui_type = _world.ui_external;
754 load_supported_properties(_property_descriptors);
755 allocate_atom_event_buffers();
756 latency_compute_run();
760 LV2Plugin::set_block_size (pframes_t nframes)
762 #ifdef HAVE_LV2_1_2_0
763 if (_impl->opts_iface) {
764 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
765 _impl->block_length = nframes;
766 LV2_Options_Option block_size_option = {
767 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
768 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
770 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
777 LV2Plugin::requires_fixed_sized_buffers () const
779 /* This controls if Ardour will split the plugin's run()
780 * on automation events in order to pass sample-accurate automation
781 * via standard control-ports.
783 * When returning true Ardour will *not* sub-divide the process-cycle.
784 * Automation events that happen between cycle-start and cycle-end will be
785 * ignored (ctrl values are interpolated to cycle-start).
786 * NB. Atom Sequences are still sample accurate.
788 * Note: This does not guarantee a fixed block-size.
789 * e.g The process cycle may be split when looping, also
790 * the period-size may change any time: see set_block_size()
792 if (get_info()->n_inputs.n_midi() > 0) {
793 /* we don't yet implement midi buffer offsets (for split cycles).
794 * Also connect_and_run() also uses _session.transport_frame() directly
795 * (for BBT) which is not offset for plugin cycle split.
799 return _no_sample_accurate_ctrl;
802 LV2Plugin::~LV2Plugin ()
804 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
809 lilv_instance_free(_impl->instance);
810 lilv_state_free(_impl->state);
811 lilv_node_free(_impl->name);
812 lilv_node_free(_impl->author);
813 #ifdef HAVE_LV2_1_2_0
814 free(_impl->options);
817 free(_impl->queue_draw);
821 free(_log_feature.data);
822 free(_make_path_feature.data);
823 free(_work_schedule_feature.data);
829 if (_atom_ev_buffers) {
830 LV2_Evbuf** b = _atom_ev_buffers;
835 free(_atom_ev_buffers);
838 delete [] _control_data;
839 delete [] _shadow_data;
841 delete [] _ev_buffers;
846 LV2Plugin::is_external_ui() const
851 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
855 LV2Plugin::is_external_kx() const
860 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
864 LV2Plugin::ui_is_resizable () const
866 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
867 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
868 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
869 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
871 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
872 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
874 lilv_nodes_free(nrs_matches);
875 lilv_nodes_free(fs_matches);
880 return !fs_matches && !nrs_matches;
885 LV2Plugin::has_inline_display () {
886 return _display_interface ? true : false;
889 Plugin::Display_Image_Surface*
890 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
891 if (_display_interface) {
892 /* Plugin::Display_Image_Surface is identical to
893 * LV2_Inline_Display_Image_Surface */
894 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
901 LV2Plugin::unique_id() const
903 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
907 LV2Plugin::uri() const
909 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
913 LV2Plugin::label() const
915 return lilv_node_as_string(_impl->name);
919 LV2Plugin::name() const
921 return lilv_node_as_string(_impl->name);
925 LV2Plugin::maker() const
927 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
931 LV2Plugin::num_ports() const
933 return lilv_plugin_get_num_ports(_impl->plugin);
937 LV2Plugin::parameter_count() const
939 return lilv_plugin_get_num_ports(_impl->plugin);
943 LV2Plugin::default_value(uint32_t port)
945 return _defaults[port];
949 LV2Plugin::port_symbol(uint32_t index) const
951 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
953 error << name() << ": Invalid port index " << index << endmsg;
956 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
957 return lilv_node_as_string(sym);
961 LV2Plugin::port_index (const char* symbol) const
963 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
964 if (i != _port_indices.end()) {
967 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
973 LV2Plugin::set_parameter(uint32_t which, float val)
975 DEBUG_TRACE(DEBUG::LV2, string_compose(
976 "%1 set parameter %2 to %3\n", name(), which, val));
978 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
979 if (get_parameter (which) == val) {
983 _shadow_data[which] = val;
985 warning << string_compose(
986 _("Illegal parameter number used with plugin \"%1\". "
987 "This is a bug in either %2 or the LV2 plugin <%3>"),
988 name(), PROGRAM_NAME, unique_id()) << endmsg;
991 Plugin::set_parameter(which, val);
995 LV2Plugin::get_parameter(uint32_t which) const
997 if (parameter_is_input(which)) {
998 return (float)_shadow_data[which];
1000 return (float)_control_data[which];
1006 LV2Plugin::get_docs() const
1008 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1010 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1011 lilv_nodes_free(comments);
1019 LV2Plugin::get_parameter_docs(uint32_t which) const
1021 LilvNodes* comments = lilv_port_get_value(
1023 lilv_plugin_get_port_by_index(_impl->plugin, which),
1024 _world.rdfs_comment);
1027 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1028 lilv_nodes_free(comments);
1036 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1039 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1040 if (parameter_is_control(x)) {
1052 LV2Plugin::extension_data(const char* uri) const
1054 return lilv_instance_get_extension_data(_impl->instance, uri);
1058 LV2Plugin::c_plugin()
1060 return _impl->plugin;
1066 return (const void*)_impl->ui;
1070 LV2Plugin::c_ui_type()
1072 return (const void*)_impl->ui_type;
1075 /** Directory for all plugin state. */
1077 LV2Plugin::plugin_dir() const
1079 if (!_plugin_state_dir.empty ()){
1080 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1082 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1086 /** Directory for files created by the plugin (except during save). */
1088 LV2Plugin::scratch_dir() const
1090 return Glib::build_filename(plugin_dir(), "scratch");
1093 /** Directory for snapshots of files in the scratch directory. */
1095 LV2Plugin::file_dir() const
1097 return Glib::build_filename(plugin_dir(), "files");
1100 /** Directory to save state snapshot version @c num into. */
1102 LV2Plugin::state_dir(unsigned num) const
1104 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1107 /** Implementation of state:makePath for files created at instantiation time.
1108 * Note this is not used for files created at save time (Lilv deals with that).
1111 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1114 LV2Plugin* me = (LV2Plugin*)handle;
1115 if (me->_insert_id == PBD::ID("0")) {
1116 warning << string_compose(
1117 "File path \"%1\" requested but LV2 %2 has no insert ID",
1118 path, me->name()) << endmsg;
1119 return g_strdup(path);
1122 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1123 const std::string dirname = Glib::path_get_dirname(abs_path);
1124 g_mkdir_with_parents(dirname.c_str(), 0744);
1126 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1129 return g_strndup(abs_path.c_str(), abs_path.length());
1133 LV2Plugin::add_state(XMLNode* root) const
1135 assert(_insert_id != PBD::ID("0"));
1141 for (uint32_t i = 0; i < parameter_count(); ++i) {
1142 if (parameter_is_input(i) && parameter_is_control(i)) {
1143 child = new XMLNode("Port");
1144 child->add_property("symbol", port_symbol(i));
1145 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1146 child->add_property("value", string(buf));
1147 root->add_child_nocopy(*child);
1151 if (!_plugin_state_dir.empty()) {
1152 root->add_property("template-dir", _plugin_state_dir);
1155 if (_has_state_interface) {
1156 // Provisionally increment state version and create directory
1157 const std::string new_dir = state_dir(++_state_version);
1158 g_mkdir_with_parents(new_dir.c_str(), 0744);
1160 LilvState* state = lilv_state_new_from_instance(
1163 _uri_map.urid_map(),
1164 scratch_dir().c_str(),
1166 _session.externals_dir().c_str(),
1169 const_cast<LV2Plugin*>(this),
1173 if (!_plugin_state_dir.empty()
1175 || !lilv_state_equals(state, _impl->state)) {
1176 lilv_state_save(_world.world,
1177 _uri_map.urid_map(),
1178 _uri_map.urid_unmap(),
1184 if (_plugin_state_dir.empty()) {
1185 // normal session save
1186 lilv_state_free(_impl->state);
1187 _impl->state = state;
1189 // template save (dedicated state-dir)
1190 lilv_state_free(state);
1193 // State is identical, decrement version and nuke directory
1194 lilv_state_free(state);
1195 PBD::remove_directory(new_dir);
1199 root->add_property("state-dir", string_compose("state%1", _state_version));
1203 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1205 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1207 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1209 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1210 lilv_nodes_free(vs);
1217 LV2Plugin::find_presets()
1219 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1220 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1221 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1223 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1224 LILV_FOREACH(nodes, i, presets) {
1225 const LilvNode* preset = lilv_nodes_get(presets, i);
1226 lilv_world_load_resource(_world.world, preset);
1227 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1228 bool userpreset = true; // TODO
1230 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1231 Plugin::PresetRecord(
1232 lilv_node_as_string(preset),
1233 lilv_node_as_string(name),
1235 lilv_node_free(name);
1237 warning << string_compose(
1238 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1239 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1240 lilv_node_as_string(preset)) << endmsg;
1243 lilv_nodes_free(presets);
1245 lilv_node_free(rdfs_label);
1246 lilv_node_free(pset_Preset);
1247 lilv_node_free(lv2_appliesTo);
1251 set_port_value(const char* port_symbol,
1257 LV2Plugin* self = (LV2Plugin*)user_data;
1258 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1259 return; // TODO: Support non-float ports
1262 const uint32_t port_index = self->port_index(port_symbol);
1263 if (port_index != (uint32_t)-1) {
1264 self->set_parameter(port_index, *(const float*)value);
1269 LV2Plugin::load_preset(PresetRecord r)
1271 LilvWorld* world = _world.world;
1272 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1273 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1276 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1277 lilv_state_free(state);
1278 Plugin::load_preset(r);
1281 lilv_node_free(pset);
1286 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1291 LV2Plugin *plugin = (LV2Plugin *) user_data;
1293 uint32_t index = plugin->port_index(port_symbol);
1294 if (index != (uint32_t) -1) {
1295 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1297 *size = sizeof(float);
1298 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1299 value = &plugin->_shadow_data[index];
1311 LV2Plugin::do_save_preset(string name)
1313 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1314 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1315 const string base_name = legalize_for_uri(name);
1316 const string file_name = base_name + ".ttl";
1317 const string bundle = Glib::build_filename(
1318 Glib::get_home_dir(),
1319 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1321 #ifdef HAVE_LILV_0_21_3
1322 /* delete reference to old preset (if any) */
1323 const PresetRecord* r = preset_by_label(name);
1325 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1327 lilv_world_unload_resource (_world.world, pset);
1328 lilv_node_free(pset);
1333 LilvState* state = lilv_state_new_from_instance(
1336 _uri_map.urid_map(),
1337 scratch_dir().c_str(), // file_dir
1338 bundle.c_str(), // copy_dir
1339 bundle.c_str(), // link_dir
1340 bundle.c_str(), // save_dir
1341 lv2plugin_get_port_value, // get_value
1342 (void*)this, // user_data
1343 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1344 _features // features
1347 lilv_state_set_label(state, name.c_str());
1349 _world.world, // world
1350 _uri_map.urid_map(), // map
1351 _uri_map.urid_unmap(), // unmap
1353 NULL, // uri (NULL = use file URI)
1354 bundle.c_str(), // dir
1355 file_name.c_str() // filename
1358 lilv_state_free(state);
1360 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1361 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1362 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1363 #ifdef HAVE_LILV_0_21_3
1364 lilv_world_unload_resource(_world.world, node_preset);
1365 lilv_world_unload_bundle(_world.world, node_bundle);
1367 lilv_world_load_bundle(_world.world, node_bundle);
1368 lilv_world_load_resource(_world.world, node_preset);
1369 lilv_node_free(node_bundle);
1370 lilv_node_free(node_preset);
1371 lilv_node_free(plug_name);
1376 LV2Plugin::do_remove_preset(string name)
1378 #ifdef HAVE_LILV_0_21_3
1379 /* Look up preset record by label (FIXME: ick, label as ID) */
1380 const PresetRecord* r = preset_by_label(name);
1385 /* Load a LilvState for the preset. */
1386 LilvWorld* world = _world.world;
1387 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1388 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1390 lilv_node_free(pset);
1394 /* Unload preset from world. */
1395 lilv_world_unload_resource(world, pset);
1397 /* Delete it from the file system. This will remove the preset file and the entry
1398 from the manifest. If this results in an empty manifest (i.e. the
1399 preset is the only thing in the bundle), then the bundle is removed. */
1400 lilv_state_delete(world, state);
1402 lilv_state_free(state);
1403 lilv_node_free(pset);
1405 /* Without lilv_state_delete(), we could delete the preset file, but this
1406 would leave a broken bundle/manifest around, so the preset would still
1407 be visible, but broken. Naively deleting a bundle is too dangerous, so
1408 we simply do not support preset deletion with older Lilv */
1412 LV2Plugin::has_editor() const
1414 return _impl->ui != NULL;
1418 LV2Plugin::has_message_output() const
1420 for (uint32_t i = 0; i < num_ports(); ++i) {
1421 if ((_port_flags[i] & PORT_SEQUENCE) &&
1422 (_port_flags[i] & PORT_OUTPUT)) {
1430 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1434 const uint8_t* body)
1436 const uint32_t buf_size = sizeof(UIMessage) + size;
1437 vector<uint8_t> buf(buf_size);
1439 UIMessage* msg = (UIMessage*)&buf[0];
1441 msg->protocol = protocol;
1443 memcpy(msg + 1, body, size);
1445 return (dest->write(&buf[0], buf_size) == buf_size);
1449 LV2Plugin::write_from_ui(uint32_t index,
1452 const uint8_t* body)
1455 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1456 /* buffer data communication from plugin UI to plugin instance.
1457 * this buffer needs to potentially hold
1458 * (port's minimumSize) * (audio-periods) / (UI-periods)
1461 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1462 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1463 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1465 * it is NOT safe to overflow (msg.size will be misinterpreted)
1467 uint32_t bufsiz = 32768;
1468 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1469 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1471 rbs = max((size_t) bufsiz * 8, rbs);
1472 _from_ui = new RingBuffer<uint8_t>(rbs);
1475 if (!write_to(_from_ui, index, protocol, size, body)) {
1476 error << "Error writing from UI to plugin" << endmsg;
1483 LV2Plugin::write_to_ui(uint32_t index,
1486 const uint8_t* body)
1488 if (!write_to(_to_ui, index, protocol, size, body)) {
1489 error << "Error writing from plugin to UI" << endmsg;
1496 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1498 switch (value.type()) {
1499 case Variant::NOTHING:
1501 case Variant::BEATS:
1502 // No atom type for this, just forge a double
1503 lv2_atom_forge_double(forge, value.get_beats().to_double());
1506 lv2_atom_forge_bool(forge, value.get_bool());
1508 case Variant::DOUBLE:
1509 lv2_atom_forge_double(forge, value.get_double());
1511 case Variant::FLOAT:
1512 lv2_atom_forge_float(forge, value.get_float());
1515 lv2_atom_forge_int(forge, value.get_int());
1518 lv2_atom_forge_long(forge, value.get_long());
1521 lv2_atom_forge_path(
1522 forge, value.get_path().c_str(), value.get_path().size());
1524 case Variant::STRING:
1525 lv2_atom_forge_string(
1526 forge, value.get_string().c_str(), value.get_string().size());
1530 forge, value.get_uri().c_str(), value.get_uri().size());
1535 /** Get a variant type from a URI, return false iff no match found. */
1537 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1539 if (uri == LV2_ATOM__Bool) {
1540 type = Variant::BOOL;
1541 } else if (uri == LV2_ATOM__Double) {
1542 type = Variant::DOUBLE;
1543 } else if (uri == LV2_ATOM__Float) {
1544 type = Variant::FLOAT;
1545 } else if (uri == LV2_ATOM__Int) {
1546 type = Variant::INT;
1547 } else if (uri == LV2_ATOM__Long) {
1548 type = Variant::LONG;
1549 } else if (uri == LV2_ATOM__Path) {
1550 type = Variant::PATH;
1551 } else if (uri == LV2_ATOM__String) {
1552 type = Variant::STRING;
1553 } else if (uri == LV2_ATOM__URI) {
1554 type = Variant::URI;
1562 LV2Plugin::set_property(uint32_t key, const Variant& value)
1564 if (_patch_port_in_index == (uint32_t)-1) {
1565 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1567 } else if (value.type() == Variant::NOTHING) {
1568 error << "LV2: set_property called with void value" << endmsg;
1572 // Set up forge to write to temporary buffer on the stack
1573 LV2_Atom_Forge* forge = &_impl->ui_forge;
1574 LV2_Atom_Forge_Frame frame;
1575 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1577 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1579 // Serialize patch:Set message to set property
1580 #ifdef HAVE_LV2_1_10_0
1581 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1582 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1583 lv2_atom_forge_urid(forge, key);
1584 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1586 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1587 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1588 lv2_atom_forge_urid(forge, key);
1589 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1592 forge_variant(forge, value);
1594 // Write message to UI=>Plugin ring
1595 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1596 write_from_ui(_patch_port_in_index,
1597 _uri_map.urids.atom_eventTransfer,
1598 lv2_atom_total_size(atom),
1599 (const uint8_t*)atom);
1602 const ParameterDescriptor&
1603 LV2Plugin::get_property_descriptor(uint32_t id) const
1605 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1606 if (p != _property_descriptors.end()) {
1609 return Plugin::get_property_descriptor(id);
1613 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1615 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1616 desc.unit = ParameterDescriptor::MIDI_NOTE;
1617 } else if (lilv_nodes_contains(units, _world.units_db)) {
1618 desc.unit = ParameterDescriptor::DB;
1619 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1620 desc.unit = ParameterDescriptor::HZ;
1622 if (lilv_nodes_size(units) > 0) {
1623 const LilvNode* unit = lilv_nodes_get_first(units);
1624 LilvNode* render = get_value(lworld, unit, _world.units_render);
1626 desc.print_fmt = lilv_node_as_string(render);
1627 lilv_node_free(render);
1633 load_parameter_descriptor(LV2World& world,
1634 ParameterDescriptor& desc,
1635 Variant::Type datatype,
1636 const LilvNode* subject)
1638 LilvWorld* lworld = _world.world;
1639 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1640 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1641 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1642 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1643 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1645 desc.label = lilv_node_as_string(label);
1647 if (def && lilv_node_is_float(def)) {
1648 desc.normal = lilv_node_as_float(def);
1650 if (minimum && lilv_node_is_float(minimum)) {
1651 desc.lower = lilv_node_as_float(minimum);
1653 if (maximum && lilv_node_is_float(maximum)) {
1654 desc.upper = lilv_node_as_float(maximum);
1656 load_parameter_descriptor_units(lworld, desc, units);
1657 desc.datatype = datatype;
1658 desc.toggled |= datatype == Variant::BOOL;
1659 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1660 desc.update_steps();
1662 lilv_nodes_free(units);
1663 lilv_node_free(label);
1664 lilv_node_free(def);
1665 lilv_node_free(minimum);
1666 lilv_node_free(maximum);
1670 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1672 LilvWorld* lworld = _world.world;
1673 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1674 LilvNodes* properties = lilv_world_find_nodes(
1675 lworld, subject, _world.patch_writable, NULL);
1676 LILV_FOREACH(nodes, p, properties) {
1677 // Get label and range
1678 const LilvNode* prop = lilv_nodes_get(properties, p);
1679 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1681 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1682 lilv_node_as_uri(prop)) << endmsg;
1686 // Convert range to variant type (TODO: support for multiple range types)
1687 Variant::Type datatype;
1688 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1689 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1690 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1694 // Add description to result
1695 ParameterDescriptor desc;
1696 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1697 desc.datatype = datatype;
1698 load_parameter_descriptor(_world, desc, datatype, prop);
1699 descs.insert(std::make_pair(desc.key, desc));
1701 lilv_node_free(range);
1703 lilv_nodes_free(properties);
1707 LV2Plugin::announce_property_values()
1709 if (_patch_port_in_index == (uint32_t)-1) {
1713 // Set up forge to write to temporary buffer on the stack
1714 LV2_Atom_Forge* forge = &_impl->ui_forge;
1715 LV2_Atom_Forge_Frame frame;
1716 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1718 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1720 // Serialize patch:Get message with no subject (implicitly plugin instance)
1721 #ifdef HAVE_LV2_1_10_0
1722 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1724 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1727 // Write message to UI=>Plugin ring
1728 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1729 write_from_ui(_patch_port_in_index,
1730 _uri_map.urids.atom_eventTransfer,
1731 lv2_atom_total_size(atom),
1732 (const uint8_t*)atom);
1736 LV2Plugin::enable_ui_emission()
1739 /* see note in LV2Plugin::write_from_ui() */
1740 uint32_t bufsiz = 32768;
1741 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1742 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1744 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1745 rbs = max((size_t) bufsiz * 8, rbs);
1746 _to_ui = new RingBuffer<uint8_t>(rbs);
1751 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1757 uint32_t read_space = _to_ui->read_space();
1758 while (read_space > sizeof(UIMessage)) {
1760 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1761 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1764 vector<uint8_t> body(msg.size);
1765 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1766 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1770 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1772 read_space -= sizeof(msg) + msg.size;
1777 LV2Plugin::work(uint32_t size, const void* data)
1779 return _impl->work_iface->work(
1780 _impl->instance->lv2_handle, work_respond, this, size, data);
1784 LV2Plugin::work_response(uint32_t size, const void* data)
1786 return _impl->work_iface->work_response(
1787 _impl->instance->lv2_handle, size, data);
1791 LV2Plugin::set_insert_id(PBD::ID id)
1793 if (_insert_id == "0") {
1795 } else if (_insert_id != id) {
1796 lilv_state_free(_impl->state);
1797 _impl->state = NULL;
1803 LV2Plugin::set_state_dir (const std::string& d)
1805 _plugin_state_dir = d;
1809 LV2Plugin::set_state(const XMLNode& node, int version)
1812 XMLProperty const * prop;
1813 XMLNodeConstIterator iter;
1820 if (node.name() != state_node_name()) {
1821 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1825 #ifndef NO_PLUGIN_STATE
1827 if (version < 3000) {
1828 nodes = node.children("port");
1830 nodes = node.children("Port");
1833 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1837 if ((prop = child->property("symbol")) != 0) {
1838 sym = prop->value().c_str();
1840 warning << _("LV2: port has no symbol, ignored") << endmsg;
1844 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1846 if (i != _port_indices.end()) {
1847 port_id = i->second;
1849 warning << _("LV2: port has unknown index, ignored") << endmsg;
1853 if ((prop = child->property("value")) != 0) {
1854 value = prop->value().c_str();
1856 warning << _("LV2: port has no value, ignored") << endmsg;
1860 set_parameter(port_id, atof(value));
1863 if ((prop = node.property("template-dir")) != 0) {
1864 set_state_dir (prop->value ());
1868 if ((prop = node.property("state-dir")) != 0) {
1869 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1870 error << string_compose(
1871 "LV2: failed to parse state version from \"%1\"",
1872 prop->value()) << endmsg;
1875 std::string state_file = Glib::build_filename(
1877 Glib::build_filename(prop->value(), "state.ttl"));
1879 LilvState* state = lilv_state_new_from_file(
1880 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1882 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1883 lilv_state_free(_impl->state);
1884 _impl->state = state;
1887 if (!_plugin_state_dir.empty ()) {
1888 // force save with session, next time (increment counter)
1889 lilv_state_free (_impl->state);
1890 _impl->state = NULL;
1894 latency_compute_run();
1897 return Plugin::set_state(node, version);
1901 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1903 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1905 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1910 LilvNodes* portunits;
1911 LilvNode *def, *min, *max;
1912 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1913 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1915 // TODO: Once we can rely on lilv 0.18.0 being present,
1916 // load_parameter_descriptor() can be used for ports as well
1917 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1918 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1919 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1920 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1921 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1922 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1923 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1924 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1925 load_parameter_descriptor_units(_world.world, desc, portunits);
1927 if (desc.sr_dependent) {
1928 desc.lower *= _session.frame_rate ();
1929 desc.upper *= _session.frame_rate ();
1932 desc.min_unbound = false; // TODO: LV2 extension required
1933 desc.max_unbound = false; // TODO: LV2 extension required
1935 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1936 desc.scale_points = get_scale_points(which);
1938 desc.update_steps();
1940 lilv_node_free(def);
1941 lilv_node_free(min);
1942 lilv_node_free(max);
1943 lilv_nodes_free(portunits);
1948 Plugin::IOPortDescription
1949 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
1951 PortFlags match = 0;
1953 case DataType::AUDIO:
1956 case DataType::MIDI:
1957 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
1960 return Plugin::IOPortDescription ("?");
1964 match |= PORT_INPUT;
1966 match |= PORT_OUTPUT;
1970 uint32_t idx = UINT32_MAX;
1972 uint32_t const num_ports = parameter_count();
1973 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1974 PortFlags flags = _port_flags[port_index];
1975 if ((flags & match) == match) {
1982 if (idx == UINT32_MAX) {
1983 return Plugin::IOPortDescription ("?");
1986 LilvNode* name = lilv_port_get_name(_impl->plugin,
1987 lilv_plugin_get_port_by_index(_impl->plugin, idx));
1988 Plugin::IOPortDescription iod (lilv_node_as_string (name));
1989 lilv_node_free(name);
1991 if (lilv_port_has_property(_impl->plugin,
1992 lilv_plugin_get_port_by_index(_impl->plugin, idx), _world.lv2_isSideChain)) {
1993 iod.is_sidechain = true;
1999 LV2Plugin::describe_parameter(Evoral::Parameter which)
2001 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2003 if (lilv_port_has_property(_impl->plugin,
2004 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2005 return X_("hidden");
2008 if (lilv_port_has_property(_impl->plugin,
2009 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2010 return X_("hidden");
2013 if (lilv_port_has_property(_impl->plugin,
2014 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2015 return X_("latency");
2018 LilvNode* name = lilv_port_get_name(_impl->plugin,
2019 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2020 string ret(lilv_node_as_string(name));
2021 lilv_node_free(name);
2029 LV2Plugin::max_latency () const
2031 return _max_latency;
2035 LV2Plugin::signal_latency() const
2037 if (_latency_control_port) {
2038 return (framecnt_t)floor(*_latency_control_port);
2044 set<Evoral::Parameter>
2045 LV2Plugin::automatable() const
2047 set<Evoral::Parameter> ret;
2049 for (uint32_t i = 0; i < parameter_count(); ++i) {
2050 if (parameter_is_input(i) && parameter_is_control(i)) {
2051 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2055 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2056 p != _property_descriptors.end();
2058 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2064 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2066 if ((_port_flags[i] & PORT_CTRLED)) {
2067 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2071 LV2Plugin::AutomationCtrlPtr
2072 LV2Plugin::get_automation_control (uint32_t i)
2074 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2075 return AutomationCtrlPtr ();
2077 return _ctrl_map[i];
2081 LV2Plugin::activate()
2083 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2085 if (!_was_activated) {
2086 lilv_instance_activate(_impl->instance);
2087 _was_activated = true;
2092 LV2Plugin::deactivate()
2094 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2096 if (_was_activated) {
2097 lilv_instance_deactivate(_impl->instance);
2098 _was_activated = false;
2103 LV2Plugin::cleanup()
2105 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2108 lilv_instance_free(_impl->instance);
2109 _impl->instance = NULL;
2113 LV2Plugin::allocate_atom_event_buffers()
2115 /* reserve local scratch buffers for ATOM event-queues */
2116 const LilvPlugin* p = _impl->plugin;
2118 /* count non-MIDI atom event-ports
2119 * TODO: nicely ask drobilla to make a lilv_ call for that
2121 int count_atom_out = 0;
2122 int count_atom_in = 0;
2123 int minimumSize = 32768; // TODO use a per-port minimum-size
2124 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2125 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2126 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2127 LilvNodes* buffer_types = lilv_port_get_value(
2128 p, port, _world.atom_bufferType);
2129 LilvNodes* atom_supports = lilv_port_get_value(
2130 p, port, _world.atom_supports);
2132 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2133 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2136 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2139 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2140 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2141 if (min_size && lilv_node_is_int(min_size)) {
2142 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2144 lilv_nodes_free(min_size_v);
2146 lilv_nodes_free(buffer_types);
2147 lilv_nodes_free(atom_supports);
2151 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2152 name(), count_atom_in, count_atom_out));
2154 const int total_atom_buffers = (count_atom_in + count_atom_out);
2155 if (_atom_ev_buffers || total_atom_buffers == 0) {
2159 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2160 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2161 for (int i = 0; i < total_atom_buffers; ++i ) {
2162 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2163 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2165 _atom_ev_buffers[total_atom_buffers] = 0;
2169 /** Write an ardour position/time/tempo/meter as an LV2 event.
2170 * @return true on success.
2173 write_position(LV2_Atom_Forge* forge,
2175 const TempoMetric& t,
2176 Timecode::BBT_Time& bbt,
2178 framepos_t position,
2181 const URIMap::URIDs& urids = URIMap::instance().urids;
2183 uint8_t pos_buf[256];
2184 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2185 LV2_Atom_Forge_Frame frame;
2186 #ifdef HAVE_LV2_1_10_0
2187 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2188 lv2_atom_forge_key(forge, urids.time_frame);
2189 lv2_atom_forge_long(forge, position);
2190 lv2_atom_forge_key(forge, urids.time_speed);
2191 lv2_atom_forge_float(forge, speed);
2192 lv2_atom_forge_key(forge, urids.time_barBeat);
2193 lv2_atom_forge_float(forge, bbt.beats - 1 +
2194 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2195 lv2_atom_forge_key(forge, urids.time_bar);
2196 lv2_atom_forge_long(forge, bbt.bars - 1);
2197 lv2_atom_forge_key(forge, urids.time_beatUnit);
2198 lv2_atom_forge_int(forge, t.meter().note_divisor());
2199 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2200 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2201 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2202 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2204 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2205 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2206 lv2_atom_forge_long(forge, position);
2207 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2208 lv2_atom_forge_float(forge, speed);
2209 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2210 lv2_atom_forge_float(forge, bbt.beats - 1 +
2211 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2212 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2213 lv2_atom_forge_long(forge, bbt.bars - 1);
2214 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2215 lv2_atom_forge_int(forge, t.meter().note_divisor());
2216 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2217 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2218 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2219 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2222 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2223 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2224 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2225 (const uint8_t*)(atom + 1));
2229 LV2Plugin::connect_and_run(BufferSet& bufs,
2230 ChanMapping in_map, ChanMapping out_map,
2231 pframes_t nframes, framecnt_t offset)
2233 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2234 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2236 cycles_t then = get_cycles();
2238 TempoMap& tmap = _session.tempo_map();
2239 Metrics::const_iterator metric_i = tmap.metrics_end();
2240 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2242 if (_freewheel_control_port) {
2243 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2246 if (_bpm_control_port) {
2247 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2251 if (_can_write_automation && _session.transport_frame() != _next_cycle_start) {
2252 // add guard-points after locating
2253 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2254 i->second->guard = true;
2259 ChanCount bufs_count;
2260 bufs_count.set(DataType::AUDIO, 1);
2261 bufs_count.set(DataType::MIDI, 1);
2262 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2263 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2264 uint32_t const num_ports = parameter_count();
2265 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2267 uint32_t audio_in_index = 0;
2268 uint32_t audio_out_index = 0;
2269 uint32_t midi_in_index = 0;
2270 uint32_t midi_out_index = 0;
2271 uint32_t atom_port_index = 0;
2272 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2274 uint32_t index = nil_index;
2275 PortFlags flags = _port_flags[port_index];
2277 if (flags & PORT_AUDIO) {
2278 if (flags & PORT_INPUT) {
2279 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2281 ? bufs.get_audio(index).data(offset)
2282 : silent_bufs.get_audio(0).data(offset);
2284 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2286 ? bufs.get_audio(index).data(offset)
2287 : scratch_bufs.get_audio(0).data(offset);
2289 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2290 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2291 be necessary, but the mapping is illegal in some cases. Ideally
2292 that should be fixed, but this is easier...
2294 if (flags & PORT_MIDI) {
2295 if (flags & PORT_INPUT) {
2296 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2298 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2300 if (valid && bufs.count().n_midi() > index) {
2301 /* Note, ensure_lv2_bufsize() is not RT safe!
2302 * However free()/alloc() is only called if a
2303 * plugin requires a rsz:minimumSize buffersize
2304 * and the existing buffer if smaller.
2306 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2307 _ev_buffers[port_index] = bufs.get_lv2_midi(
2308 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2310 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2311 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2312 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2316 if (valid && (flags & PORT_INPUT)) {
2317 Timecode::BBT_Time bbt;
2318 if ((flags & PORT_POSITION)) {
2319 if (_session.transport_frame() != _next_cycle_start ||
2320 _session.transport_speed() != _next_cycle_speed) {
2321 // Transport has changed, write position at cycle start
2322 bbt = tmap.bbt_at_frame (_session.transport_frame());
2323 write_position(&_impl->forge, _ev_buffers[port_index],
2324 tmetric, bbt, _session.transport_speed(),
2325 _session.transport_frame(), 0);
2329 // Get MIDI iterator range (empty range if no MIDI)
2330 MidiBuffer::iterator m = (index != nil_index)
2331 ? bufs.get_midi(index).begin()
2332 : silent_bufs.get_midi(0).end();
2333 MidiBuffer::iterator m_end = (index != nil_index)
2334 ? bufs.get_midi(index).end()
2337 // Now merge MIDI and any transport events into the buffer
2338 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2339 const framepos_t tend = _session.transport_frame() + nframes;
2341 while (m != m_end || (metric_i != tmap.metrics_end() &&
2342 (*metric_i)->frame() < tend)) {
2343 MetricSection* metric = (metric_i != tmap.metrics_end())
2345 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2346 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2347 if (ev.time() < nframes) {
2348 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2349 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2353 tmetric.set_metric(metric);
2354 bbt = tmap.bbt_at_pulse (metric->pulse());
2355 write_position(&_impl->forge, _ev_buffers[port_index],
2356 tmetric, bbt, _session.transport_speed(),
2358 metric->frame() - _session.transport_frame());
2362 } else if (!valid) {
2363 // Nothing we understand or care about, connect to scratch
2364 // see note for midi-buffer size above
2365 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2366 0, _port_minimumSize[port_index]);
2367 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2368 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2371 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2373 continue; // Control port, leave buffer alone
2375 lilv_instance_connect_port(_impl->instance, port_index, buf);
2378 // Read messages from UI and push into appropriate buffers
2380 uint32_t read_space = _from_ui->read_space();
2381 while (read_space > sizeof(UIMessage)) {
2383 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2384 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2387 vector<uint8_t> body(msg.size);
2388 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2389 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2392 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2393 LV2_Evbuf* buf = _ev_buffers[msg.index];
2394 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2395 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2396 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2397 (const uint8_t*)(atom + 1))) {
2398 error << "Failed to write data to LV2 event buffer\n";
2401 error << "Received unknown message type from UI" << endmsg;
2403 read_space -= sizeof(UIMessage) + msg.size;
2410 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2411 PortFlags flags = _port_flags[port_index];
2414 /* TODO ask drobilla about comment
2415 * "Make Ardour event buffers generic so plugins can communicate"
2416 * in libs/ardour/buffer_set.cc:310
2418 * ideally the user could choose which of the following two modes
2419 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2421 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2422 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2423 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2424 * for quite a while at least ;)
2426 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2427 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2428 const uint32_t buf_index = out_map.get(
2429 DataType::MIDI, midi_out_index++, &valid);
2431 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2434 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2435 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2436 const uint32_t buf_index = out_map.get(
2437 DataType::MIDI, midi_out_index++, &valid);
2439 bufs.flush_lv2_midi(true, buf_index);
2443 // Write messages to UI
2444 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2445 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2446 LV2_Evbuf* buf = _ev_buffers[port_index];
2447 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2448 lv2_evbuf_is_valid(i);
2449 i = lv2_evbuf_next(i)) {
2450 uint32_t frames, subframes, type, size;
2452 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2455 // Intercept Automation Write Events
2456 if ((flags & PORT_AUTOCTRL)) {
2457 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2458 if (atom->type == _uri_map.urids.atom_Blank ||
2459 atom->type == _uri_map.urids.atom_Object) {
2460 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2461 if (obj->body.otype == _uri_map.urids.auto_event) {
2462 // only if transport_rolling ??
2463 const LV2_Atom* parameter = NULL;
2464 const LV2_Atom* value = NULL;
2465 lv2_atom_object_get(obj,
2466 _uri_map.urids.auto_parameter, ¶meter,
2467 _uri_map.urids.auto_value, &value,
2469 if (parameter && value) {
2470 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2471 const float v = ((const LV2_Atom_Float*)value)->body;
2472 // -> add automation event..
2473 AutomationCtrlPtr c = get_automation_control (p);
2474 if (c && c->ac->automation_state() == Touch) {
2477 c->ac->list()->add (_session.transport_frame() + frames, v, true, true);
2479 c->ac->set_double (v, _session.transport_frame() + frames, true);
2484 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2485 // TODO optional arguments, for now we assume the plugin
2486 // writes automation for its own inputs
2487 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2488 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2489 i->second->ac->set_automation_state (Touch);
2492 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2493 // set [touched] parameters to "play" ??
2495 else if (obj->body.otype == _uri_map.urids.auto_start) {
2496 const LV2_Atom* parameter = NULL;
2497 lv2_atom_object_get(obj,
2498 _uri_map.urids.auto_parameter, ¶meter,
2501 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2502 AutomationCtrlPtr c = get_automation_control (p);
2504 c->ac->start_touch (_session.transport_frame());
2509 else if (obj->body.otype == _uri_map.urids.auto_end) {
2510 const LV2_Atom* parameter = NULL;
2511 lv2_atom_object_get(obj,
2512 _uri_map.urids.auto_parameter, ¶meter,
2515 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2516 AutomationCtrlPtr c = get_automation_control (p);
2518 c->ac->stop_touch (true, _session.transport_frame());
2526 // Intercept patch change messages to emit PropertyChanged signal
2527 if ((flags & PORT_PATCHMSG)) {
2528 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2529 if (atom->type == _uri_map.urids.atom_Blank ||
2530 atom->type == _uri_map.urids.atom_Object) {
2531 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2532 if (obj->body.otype == _uri_map.urids.patch_Set) {
2533 const LV2_Atom* property = NULL;
2534 const LV2_Atom* value = NULL;
2535 lv2_atom_object_get(obj,
2536 _uri_map.urids.patch_property, &property,
2537 _uri_map.urids.patch_value, &value,
2540 if (property && value &&
2541 property->type == _uri_map.urids.atom_URID &&
2542 value->type == _uri_map.urids.atom_Path) {
2543 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2544 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2546 // Emit PropertyChanged signal for UI
2547 // TODO: This should emit the control's Changed signal
2548 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2550 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2556 if (!_to_ui) continue;
2557 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2558 size + sizeof(LV2_Atom),
2559 data - sizeof(LV2_Atom));
2564 cycles_t now = get_cycles();
2565 set_cycles((uint32_t)(now - then));
2567 // Update expected transport information for next cycle so we can detect changes
2568 _next_cycle_speed = _session.transport_speed();
2569 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2571 if (_latency_control_port) {
2572 framecnt_t new_latency = signal_latency ();
2573 if (_current_latency != new_latency) {
2574 LatencyChanged (_current_latency, new_latency); /* EMIT SIGNAL */
2576 _current_latency = new_latency;
2582 LV2Plugin::parameter_is_control(uint32_t param) const
2584 assert(param < _port_flags.size());
2585 return _port_flags[param] & PORT_CONTROL;
2589 LV2Plugin::parameter_is_audio(uint32_t param) const
2591 assert(param < _port_flags.size());
2592 return _port_flags[param] & PORT_AUDIO;
2596 LV2Plugin::parameter_is_event(uint32_t param) const
2598 assert(param < _port_flags.size());
2599 return _port_flags[param] & PORT_EVENT;
2603 LV2Plugin::parameter_is_output(uint32_t param) const
2605 assert(param < _port_flags.size());
2606 return _port_flags[param] & PORT_OUTPUT;
2610 LV2Plugin::parameter_is_input(uint32_t param) const
2612 assert(param < _port_flags.size());
2613 return _port_flags[param] & PORT_INPUT;
2617 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2620 if (param < parameter_count()) {
2621 snprintf(buf, len, "%.3f", get_parameter(param));
2628 boost::shared_ptr<ScalePoints>
2629 LV2Plugin::get_scale_points(uint32_t port_index) const
2631 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2632 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2634 boost::shared_ptr<ScalePoints> ret;
2639 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2641 LILV_FOREACH(scale_points, i, points) {
2642 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2643 const LilvNode* label = lilv_scale_point_get_label(p);
2644 const LilvNode* value = lilv_scale_point_get_value(p);
2645 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2646 ret->insert(make_pair(lilv_node_as_string(label),
2647 lilv_node_as_float(value)));
2651 lilv_scale_points_free(points);
2656 LV2Plugin::run(pframes_t nframes)
2658 uint32_t const N = parameter_count();
2659 for (uint32_t i = 0; i < N; ++i) {
2660 if (parameter_is_control(i) && parameter_is_input(i)) {
2661 _control_data[i] = _shadow_data[i];
2665 lilv_instance_run(_impl->instance, nframes);
2667 if (_impl->work_iface) {
2668 _worker->emit_responses();
2669 if (_impl->work_iface->end_run) {
2670 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2676 LV2Plugin::latency_compute_run()
2678 if (!_latency_control_port) {
2682 // Run the plugin so that it can set its latency parameter
2684 bool was_activated = _was_activated;
2687 uint32_t port_index = 0;
2688 uint32_t in_index = 0;
2689 uint32_t out_index = 0;
2691 // this is done in the main thread. non realtime.
2692 const framecnt_t bufsize = _engine.samples_per_cycle();
2693 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2695 memset(buffer, 0, sizeof(float) * bufsize);
2697 // FIXME: Ensure plugins can handle in-place processing
2701 while (port_index < parameter_count()) {
2702 if (parameter_is_audio(port_index)) {
2703 if (parameter_is_input(port_index)) {
2704 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2706 } else if (parameter_is_output(port_index)) {
2707 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2716 if (was_activated) {
2723 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2725 const LilvPort* port = NULL;
2726 LilvNode* designation = lilv_new_uri(_world.world, uri);
2727 port = lilv_plugin_get_port_by_designation(
2728 plugin, _world.lv2_InputPort, designation);
2729 lilv_node_free(designation);
2731 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2736 static bool lv2_filter (const string& str, void* /*arg*/)
2738 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2740 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2744 LV2World::LV2World()
2745 : world(lilv_world_new())
2746 , _bundle_checked(false)
2748 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2749 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2750 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2751 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2752 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2753 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2754 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2755 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2756 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2757 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2758 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2759 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2760 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2761 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2762 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
2763 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2764 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2765 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2766 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2767 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2768 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2769 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2770 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2771 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2772 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2773 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2774 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2775 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2776 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2777 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2778 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2779 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2780 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2781 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2782 units_render = lilv_new_uri(world, LV2_UNITS__render);
2783 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2784 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2785 units_db = lilv_new_uri(world, LV2_UNITS__db);
2786 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2787 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2789 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls");
2790 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
2791 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
2792 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
2794 #ifdef HAVE_LV2_1_2_0
2795 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2796 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2797 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2802 LV2World::~LV2World()
2807 #ifdef HAVE_LV2_1_2_0
2808 lilv_node_free(bufz_nominalBlockLength);
2809 lilv_node_free(bufz_fixedBlockLength);
2810 lilv_node_free(bufz_powerOf2BlockLength);
2813 lilv_node_free(lv2_noSampleAccurateCtrl);
2814 lilv_node_free(auto_can_write_automatation);
2815 lilv_node_free(auto_automation_control);
2816 lilv_node_free(auto_automation_controlled);
2818 lilv_node_free(patch_Message);
2819 lilv_node_free(patch_writable);
2820 lilv_node_free(units_hz);
2821 lilv_node_free(units_midiNote);
2822 lilv_node_free(units_db);
2823 lilv_node_free(units_unit);
2824 lilv_node_free(units_render);
2825 lilv_node_free(ui_externalkx);
2826 lilv_node_free(ui_external);
2827 lilv_node_free(ui_GtkUI);
2828 lilv_node_free(time_Position);
2829 lilv_node_free(rsz_minimumSize);
2830 lilv_node_free(rdfs_comment);
2831 lilv_node_free(rdfs_label);
2832 lilv_node_free(rdfs_range);
2833 lilv_node_free(midi_MidiEvent);
2834 lilv_node_free(lv2_enumeration);
2835 lilv_node_free(lv2_freewheeling);
2836 lilv_node_free(lv2_toggled);
2837 lilv_node_free(lv2_sampleRate);
2838 lilv_node_free(lv2_reportsLatency);
2839 lilv_node_free(lv2_integer);
2840 lilv_node_free(lv2_isSideChain);
2841 lilv_node_free(lv2_inPlaceBroken);
2842 lilv_node_free(lv2_OutputPort);
2843 lilv_node_free(lv2_InputPort);
2844 lilv_node_free(lv2_ControlPort);
2845 lilv_node_free(lv2_AudioPort);
2846 lilv_node_free(ext_notOnGUI);
2847 lilv_node_free(ext_logarithmic);
2848 lilv_node_free(ev_EventPort);
2849 lilv_node_free(atom_supports);
2850 lilv_node_free(atom_eventTransfer);
2851 lilv_node_free(atom_bufferType);
2852 lilv_node_free(atom_Sequence);
2853 lilv_node_free(atom_Chunk);
2854 lilv_node_free(atom_AtomPort);
2855 lilv_world_free(world);
2860 LV2World::load_bundled_plugins(bool verbose)
2862 if (!_bundle_checked) {
2864 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2867 vector<string> plugin_objects;
2868 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2869 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2870 #ifdef PLATFORM_WINDOWS
2871 string uri = "file:///" + *x + "/";
2873 string uri = "file://" + *x + "/";
2875 LilvNode *node = lilv_new_uri(world, uri.c_str());
2876 lilv_world_load_bundle(world, node);
2877 lilv_node_free(node);
2880 lilv_world_load_all(world);
2881 _bundle_checked = true;
2885 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2888 _plugin_uri = strdup(plugin_uri);
2891 LV2PluginInfo::~LV2PluginInfo()
2898 LV2PluginInfo::load(Session& session)
2902 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2903 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2904 if (!uri) { throw failed_constructor(); }
2905 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2906 if (!lp) { throw failed_constructor(); }
2907 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2908 lilv_node_free(uri);
2909 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2911 } catch (failed_constructor& err) {
2912 return PluginPtr((Plugin*)0);
2918 std::vector<Plugin::PresetRecord>
2919 LV2PluginInfo::get_presets (bool /*user_only*/) const
2921 std::vector<Plugin::PresetRecord> p;
2922 #ifndef NO_PLUGIN_STATE
2923 const LilvPlugin* lp = NULL;
2926 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2927 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2928 if (!uri) { throw failed_constructor(); }
2929 lp = lilv_plugins_get_by_uri(plugins, uri);
2930 if (!lp) { throw failed_constructor(); }
2931 lilv_node_free(uri);
2932 } catch (failed_constructor& err) {
2936 // see LV2Plugin::find_presets
2937 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
2938 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
2939 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
2941 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
2942 LILV_FOREACH(nodes, i, presets) {
2943 const LilvNode* preset = lilv_nodes_get(presets, i);
2944 lilv_world_load_resource(_world.world, preset);
2945 LilvNode* name = get_value(_world.world, preset, rdfs_label);
2946 bool userpreset = true; // TODO
2948 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
2949 lilv_node_free(name);
2952 lilv_nodes_free(presets);
2953 lilv_node_free(rdfs_label);
2954 lilv_node_free(pset_Preset);
2955 lilv_node_free(lv2_appliesTo);
2961 LV2PluginInfo::in_category (const std::string &c) const
2963 // TODO use untranslated lilv_plugin_get_class()
2964 // match gtk2_ardour/plugin_selector.cc
2965 if (category == c) {
2972 LV2PluginInfo::is_instrument () const
2974 if (category == "Instrument") {
2978 /* until we make sure that category remains untranslated in the lv2.ttl spec
2979 * and until most instruments also classify themselves as such, there's a 2nd check:
2981 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2989 LV2PluginInfo::discover()
2992 world.load_bundled_plugins();
2993 _world.load_bundled_plugins(true);
2995 PluginInfoList* plugs = new PluginInfoList;
2996 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2998 LILV_FOREACH(plugins, i, plugins) {
2999 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3000 const LilvNode* pun = lilv_plugin_get_uri(p);
3002 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3004 LilvNode* name = lilv_plugin_get_name(p);
3005 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3006 warning << "Ignoring invalid LV2 plugin "
3007 << lilv_node_as_string(lilv_plugin_get_uri(p))
3012 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3013 warning << string_compose(
3014 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3015 lilv_node_as_string(name)) << endmsg;
3016 lilv_node_free(name);
3020 #ifdef HAVE_LV2_1_2_0
3021 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3022 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3023 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3025 warning << string_compose(
3026 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3027 lilv_node_as_string(name)) << endmsg;
3028 lilv_nodes_free(required_features);
3029 lilv_node_free(name);
3032 lilv_nodes_free(required_features);
3037 info->name = string(lilv_node_as_string(name));
3038 lilv_node_free(name);
3039 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3041 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3042 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3043 info->category = lilv_node_as_string(label);
3045 LilvNode* author_name = lilv_plugin_get_author_name(p);
3046 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3047 lilv_node_free(author_name);
3049 info->path = "/NOPATH"; // Meaningless for LV2
3051 /* count atom-event-ports that feature
3052 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3054 * TODO: nicely ask drobilla to make a lilv_ call for that
3056 int count_midi_out = 0;
3057 int count_midi_in = 0;
3058 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3059 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3060 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3061 LilvNodes* buffer_types = lilv_port_get_value(
3062 p, port, world.atom_bufferType);
3063 LilvNodes* atom_supports = lilv_port_get_value(
3064 p, port, world.atom_supports);
3066 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3067 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3068 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3071 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3075 lilv_nodes_free(buffer_types);
3076 lilv_nodes_free(atom_supports);
3080 info->n_inputs.set_audio(
3081 lilv_plugin_get_num_ports_of_class(
3082 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3083 info->n_inputs.set_midi(
3084 lilv_plugin_get_num_ports_of_class(
3085 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3088 info->n_outputs.set_audio(
3089 lilv_plugin_get_num_ports_of_class(
3090 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3091 info->n_outputs.set_midi(
3092 lilv_plugin_get_num_ports_of_class(
3093 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3096 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3097 info->index = 0; // Meaningless for LV2
3099 plugs->push_back(info);