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_isSideChain;
136 LilvNode* lv2_integer;
137 LilvNode* lv2_default;
138 LilvNode* lv2_minimum;
139 LilvNode* lv2_maximum;
140 LilvNode* lv2_reportsLatency;
141 LilvNode* lv2_sampleRate;
142 LilvNode* lv2_toggled;
143 LilvNode* midi_MidiEvent;
144 LilvNode* rdfs_comment;
145 LilvNode* rdfs_label;
146 LilvNode* rdfs_range;
147 LilvNode* rsz_minimumSize;
148 LilvNode* time_Position;
150 LilvNode* ui_external;
151 LilvNode* ui_externalkx;
154 LilvNode* units_unit;
155 LilvNode* units_render;
156 LilvNode* units_midiNote;
157 LilvNode* patch_writable;
158 LilvNode* patch_Message;
159 #ifdef HAVE_LV2_1_2_0
160 LilvNode* bufz_powerOf2BlockLength;
161 LilvNode* bufz_fixedBlockLength;
162 LilvNode* bufz_nominalBlockLength;
165 #ifdef HAVE_LV2_1_10_0
167 LilvNode* atom_float;
168 LilvNode* atom_object; // new in 1.8
169 LilvNode* atom_vector;
172 LilvNode* lv2_noSampleAccurateCtrl;
173 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
174 LilvNode* auto_automation_control; // atom:supports
175 LilvNode* auto_automation_controlled; // lv2:portProperty
179 bool _bundle_checked;
182 static LV2World _world;
184 /* worker extension */
186 /** Called by the plugin to schedule non-RT work. */
187 static LV2_Worker_Status
188 work_schedule(LV2_Worker_Schedule_Handle handle,
192 LV2Plugin* plugin = (LV2Plugin*)handle;
193 if (plugin->session().engine().freewheeling()) {
194 // Freewheeling, do the work immediately in this (audio) thread
195 return (LV2_Worker_Status)plugin->work(size, data);
197 // Enqueue message for the worker thread
198 return plugin->worker()->schedule(size, data) ?
199 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
203 /** Called by the plugin to respond to non-RT work. */
204 static LV2_Worker_Status
205 work_respond(LV2_Worker_Respond_Handle handle,
209 LV2Plugin* plugin = (LV2Plugin*)handle;
210 if (plugin->session().engine().freewheeling()) {
211 // Freewheeling, respond immediately in this (audio) thread
212 return (LV2_Worker_Status)plugin->work_response(size, data);
214 // Enqueue response for the worker
215 return plugin->worker()->respond(size, data) ?
216 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
221 /* inline display extension */
223 queue_draw (LV2_Inline_Display_Handle handle)
225 LV2Plugin* plugin = (LV2Plugin*)handle;
226 plugin->QueueDraw(); /* EMIT SIGNAL */
233 log_vprintf(LV2_Log_Handle /*handle*/,
239 const int ret = g_vasprintf(&str, fmt, args);
240 if (type == URIMap::instance().urids.log_Error) {
241 error << str << endmsg;
242 } else if (type == URIMap::instance().urids.log_Warning) {
243 warning << str << endmsg;
244 } else if (type == URIMap::instance().urids.log_Note) {
245 info << str << endmsg;
247 // TODO: Toggleable log:Trace message support
252 log_printf(LV2_Log_Handle handle,
254 const char* fmt, ...)
258 const int ret = log_vprintf(handle, type, fmt, args);
263 struct LV2Plugin::Impl {
264 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
266 #ifdef HAVE_LV2_1_2_0
271 #ifdef HAVE_LV2_1_2_0
279 /** Find the LV2 input port with the given designation.
280 * If found, bufptrs[port_index] will be set to bufptr.
282 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
284 const LilvPlugin* plugin;
286 const LilvNode* ui_type;
289 LilvInstance* instance;
290 const LV2_Worker_Interface* work_iface;
291 #ifdef HAVE_LV2_1_2_0
292 const LV2_Options_Interface* opts_iface;
295 LV2_Atom_Forge forge;
296 LV2_Atom_Forge ui_forge;
297 int32_t block_length;
298 #ifdef HAVE_LV2_1_2_0
299 LV2_Options_Option* options;
302 LV2_Inline_Display* queue_draw;
306 LV2Plugin::LV2Plugin (AudioEngine& engine,
308 const void* c_plugin,
310 : Plugin (engine, session)
316 , _patch_port_in_index((uint32_t)-1)
317 , _patch_port_out_index((uint32_t)-1)
318 , _uri_map(URIMap::instance())
319 , _no_sample_accurate_ctrl (false)
321 init(c_plugin, rate);
324 LV2Plugin::LV2Plugin (const LV2Plugin& other)
330 , _insert_id(other._insert_id)
331 , _patch_port_in_index((uint32_t)-1)
332 , _patch_port_out_index((uint32_t)-1)
333 , _uri_map(URIMap::instance())
334 , _no_sample_accurate_ctrl (false)
336 init(other._impl->plugin, other._sample_rate);
338 for (uint32_t i = 0; i < parameter_count(); ++i) {
339 _control_data[i] = other._shadow_data[i];
340 _shadow_data[i] = other._shadow_data[i];
345 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
347 DEBUG_TRACE(DEBUG::LV2, "init\n");
349 _impl->plugin = (const LilvPlugin*)c_plugin;
351 _impl->ui_type = NULL;
356 _atom_ev_buffers = 0;
358 _bpm_control_port = 0;
359 _freewheel_control_port = 0;
360 _latency_control_port = 0;
361 _next_cycle_start = std::numeric_limits<framepos_t>::max();
362 _next_cycle_speed = 1.0;
363 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
365 _was_activated = false;
366 _has_state_interface = false;
367 _can_write_automation = false;
369 _current_latency = 0;
370 _impl->block_length = _session.get_block_size();
372 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
373 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
374 _make_path_feature.URI = LV2_STATE__makePath;
375 _log_feature.URI = LV2_LOG__log;
376 _work_schedule_feature.URI = LV2_WORKER__schedule;
377 _work_schedule_feature.data = NULL;
378 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
379 _def_state_feature.data = NULL;
381 const LilvPlugin* plugin = _impl->plugin;
383 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
384 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
385 _has_state_interface =
386 // What plugins should have (lv2:extensionData state:Interface)
387 lilv_plugin_has_extension_data(plugin, state_iface_uri)
388 // What some outdated/incorrect ones have
389 || lilv_plugin_has_feature(plugin, state_uri);
390 lilv_node_free(state_uri);
391 lilv_node_free(state_iface_uri);
393 _features = (LV2_Feature**)calloc(12, sizeof(LV2_Feature*));
394 _features[0] = &_instance_access_feature;
395 _features[1] = &_data_access_feature;
396 _features[2] = &_make_path_feature;
397 _features[3] = _uri_map.uri_map_feature();
398 _features[4] = _uri_map.urid_map_feature();
399 _features[5] = _uri_map.urid_unmap_feature();
400 _features[6] = &_log_feature;
402 unsigned n_features = 7;
403 #ifdef HAVE_LV2_1_2_0
404 _features[n_features++] = &_def_state_feature;
407 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
408 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
411 _impl->queue_draw = (LV2_Inline_Display*)
412 malloc (sizeof(LV2_Inline_Display));
413 _impl->queue_draw->handle = this;
414 _impl->queue_draw->queue_draw = queue_draw;
416 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
417 _queue_draw_feature.data = _impl->queue_draw;
418 _features[n_features++] = &_queue_draw_feature;
421 #ifdef HAVE_LV2_1_2_0
422 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
423 static const int32_t _min_block_length = 1; // may happen during split-cycles
424 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
425 /* Consider updating max-block-size whenever the buffersize changes.
426 * It requires re-instantiating the plugin (which is a non-realtime operation),
427 * so it should be done lightly and only for plugins that require it.
429 * given that the block-size can change at any time (split-cycles) ardour currently
430 * does not support plugins that require bufz_fixedBlockLength.
432 LV2_Options_Option options[] = {
433 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
434 sizeof(int32_t), atom_Int, &_min_block_length },
435 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
436 sizeof(int32_t), atom_Int, &_max_block_length },
437 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
438 sizeof(int32_t), atom_Int, &_seq_size },
439 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
440 sizeof(int32_t), atom_Int, &_impl->block_length },
441 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
444 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
445 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
447 _options_feature.URI = LV2_OPTIONS__options;
448 _options_feature.data = _impl->options;
449 _features[n_features++] = &_options_feature;
452 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
453 sizeof(LV2_State_Make_Path));
454 make_path->handle = this;
455 make_path->path = &lv2_state_make_path;
456 _make_path_feature.data = make_path;
458 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
460 log->printf = &log_printf;
461 log->vprintf = &log_vprintf;
462 _log_feature.data = log;
464 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
465 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
466 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
467 sizeof(LV2_Worker_Schedule));
468 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
469 _worker = new Worker(this, buf_size);
470 schedule->handle = this;
471 schedule->schedule_work = work_schedule;
472 _work_schedule_feature.data = schedule;
473 _features[n_features++] = &_work_schedule_feature;
475 lilv_node_free(worker_schedule);
477 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
478 _impl->name = lilv_plugin_get_name(plugin);
479 _impl->author = lilv_plugin_get_author_name(plugin);
481 if (_impl->instance == 0) {
482 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
483 throw failed_constructor();
486 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
487 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
488 _data_access_feature.data = &_data_access_extension_data;
490 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
491 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
492 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
493 LV2_WORKER__interface);
495 lilv_node_free(worker_iface_uri);
498 #ifdef HAVE_LV2_1_2_0
499 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
500 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
501 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
502 LV2_OPTIONS__interface);
504 lilv_node_free(options_iface_uri);
508 _display_interface = (const LV2_Inline_Display_Interface*)
509 extension_data (LV2_INLINEDISPLAY__interface);
512 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
513 error << string_compose(
514 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
515 lilv_node_as_string(_impl->name)) << endmsg;
516 lilv_node_free(_impl->name);
517 lilv_node_free(_impl->author);
518 throw failed_constructor();
521 #ifdef HAVE_LV2_1_2_0
522 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
523 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
524 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
526 error << string_compose(
527 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
528 lilv_node_as_string(_impl->name)) << endmsg;
529 lilv_node_free(_impl->name);
530 lilv_node_free(_impl->author);
531 lilv_nodes_free(required_features);
532 throw failed_constructor();
534 lilv_nodes_free(required_features);
538 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
539 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
540 _no_sample_accurate_ctrl = true;
542 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
543 _can_write_automation = true;
545 lilv_nodes_free(optional_features);
548 #ifdef HAVE_LILV_0_16_0
549 // Load default state
550 LilvState* state = lilv_state_new_from_world(
551 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
552 if (state && _has_state_interface) {
553 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
555 lilv_state_free(state);
560 const uint32_t num_ports = this->num_ports();
561 for (uint32_t i = 0; i < num_ports; ++i) {
562 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
564 size_t minimumSize = 0;
566 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
567 flags |= PORT_OUTPUT;
568 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
571 error << string_compose(
572 "LV2: \"%1\" port %2 is neither input nor output",
573 lilv_node_as_string(_impl->name), i) << endmsg;
574 throw failed_constructor();
577 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
578 flags |= PORT_CONTROL;
579 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
581 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
583 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
584 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
585 LilvNodes* buffer_types = lilv_port_get_value(
586 _impl->plugin, port, _world.atom_bufferType);
587 LilvNodes* atom_supports = lilv_port_get_value(
588 _impl->plugin, port, _world.atom_supports);
590 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
591 flags |= PORT_SEQUENCE;
592 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
595 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
596 flags |= PORT_POSITION;
599 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
600 flags |= PORT_AUTOCTRL;
603 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
604 flags |= PORT_PATCHMSG;
605 if (flags & PORT_INPUT) {
606 _patch_port_in_index = i;
608 _patch_port_out_index = i;
612 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
613 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
614 if (min_size && lilv_node_is_int(min_size)) {
615 minimumSize = lilv_node_as_int(min_size);
617 lilv_nodes_free(min_size_v);
618 lilv_nodes_free(buffer_types);
619 lilv_nodes_free(atom_supports);
621 error << string_compose(
622 "LV2: \"%1\" port %2 has no known data type",
623 lilv_node_as_string(_impl->name), i) << endmsg;
624 throw failed_constructor();
628 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
629 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
630 flags |= PORT_CTRLED;
635 _port_flags.push_back(flags);
636 _port_minimumSize.push_back(minimumSize);
639 _control_data = new float[num_ports];
640 _shadow_data = new float[num_ports];
641 _defaults = new float[num_ports];
642 _ev_buffers = new LV2_Evbuf*[num_ports];
643 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
645 const bool latent = lilv_plugin_has_latency(plugin);
646 const uint32_t latency_index = (latent)
647 ? lilv_plugin_get_latency_port_index(plugin)
650 // Build an array of pointers to special parameter buffers
651 void*** params = new void**[num_ports];
652 for (uint32_t i = 0; i < num_ports; ++i) {
655 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
656 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
658 for (uint32_t i = 0; i < num_ports; ++i) {
659 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
660 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
662 // Store index in map so we can look up index by symbol
663 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
665 // Get range and default value if applicable
666 if (parameter_is_control(i)) {
668 lilv_port_get_range(plugin, port, &def, NULL, NULL);
669 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
670 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
671 _defaults[i] *= _session.frame_rate ();
675 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
677 if (latent && i == latency_index) {
679 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
680 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
681 _latency_control_port = &_control_data[i];
682 *_latency_control_port = 0;
685 if (parameter_is_input(i)) {
686 _shadow_data[i] = default_value(i);
688 *params[i] = (void*)&_shadow_data[i];
698 LilvUIs* uis = lilv_plugin_get_uis(plugin);
699 if (lilv_uis_size(uis) > 0) {
701 // Look for embeddable UI
702 LILV_FOREACH(uis, u, uis) {
703 const LilvUI* this_ui = lilv_uis_get(uis, u);
704 const LilvNode* this_ui_type = NULL;
705 if (lilv_ui_is_supported(this_ui,
709 // TODO: Multiple UI support
711 _impl->ui_type = this_ui_type;
716 // Look for Gtk native UI
717 LILV_FOREACH(uis, i, uis) {
718 const LilvUI* ui = lilv_uis_get(uis, i);
719 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
721 _impl->ui_type = _world.ui_GtkUI;
727 // If Gtk UI is not available, try to find external UI
729 LILV_FOREACH(uis, i, uis) {
730 const LilvUI* ui = lilv_uis_get(uis, i);
731 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
733 _impl->ui_type = _world.ui_external;
736 if (lilv_ui_is_a(ui, _world.ui_external)) {
738 _impl->ui_type = _world.ui_external;
744 load_supported_properties(_property_descriptors);
745 allocate_atom_event_buffers();
746 latency_compute_run();
750 LV2Plugin::set_block_size (pframes_t nframes)
752 #ifdef HAVE_LV2_1_2_0
753 if (_impl->opts_iface) {
754 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
755 _impl->block_length = nframes;
756 LV2_Options_Option block_size_option = {
757 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
758 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
760 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
767 LV2Plugin::requires_fixed_sized_buffers () const
769 /* This controls if Ardour will split the plugin's run()
770 * on automation events in order to pass sample-accurate automation
771 * via standard control-ports.
773 * When returning true Ardour will *not* sub-divide the process-cycle.
774 * Automation events that happen between cycle-start and cycle-end will be
775 * ignored (ctrl values are interpolated to cycle-start).
776 * NB. Atom Sequences are still sample accurate.
778 * Note: This does not guarantee a fixed block-size.
779 * e.g The process cycle may be split when looping, also
780 * the period-size may change any time: see set_block_size()
782 if (get_info()->n_inputs.n_midi() > 0) {
783 /* we don't yet implement midi buffer offsets (for split cycles).
784 * Also connect_and_run() also uses _session.transport_frame() directly
785 * (for BBT) which is not offset for plugin cycle split.
789 return _no_sample_accurate_ctrl;
792 LV2Plugin::~LV2Plugin ()
794 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
799 lilv_instance_free(_impl->instance);
800 lilv_state_free(_impl->state);
801 lilv_node_free(_impl->name);
802 lilv_node_free(_impl->author);
803 #ifdef HAVE_LV2_1_2_0
804 free(_impl->options);
807 free(_impl->queue_draw);
811 free(_make_path_feature.data);
812 free(_work_schedule_feature.data);
818 if (_atom_ev_buffers) {
819 LV2_Evbuf** b = _atom_ev_buffers;
824 free(_atom_ev_buffers);
827 delete [] _control_data;
828 delete [] _shadow_data;
830 delete [] _ev_buffers;
834 LV2Plugin::is_external_ui() const
839 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
843 LV2Plugin::is_external_kx() const
848 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
852 LV2Plugin::ui_is_resizable () const
854 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
855 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
856 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
857 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
859 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
860 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
862 lilv_nodes_free(nrs_matches);
863 lilv_nodes_free(fs_matches);
868 return !fs_matches && !nrs_matches;
873 LV2Plugin::has_inline_display () {
874 return _display_interface ? true : false;
877 Plugin::Display_Image_Surface*
878 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
879 if (_display_interface) {
880 /* Plugin::Display_Image_Surface is identical to
881 * LV2_Inline_Display_Image_Surface */
882 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
889 LV2Plugin::unique_id() const
891 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
895 LV2Plugin::uri() const
897 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
901 LV2Plugin::label() const
903 return lilv_node_as_string(_impl->name);
907 LV2Plugin::name() const
909 return lilv_node_as_string(_impl->name);
913 LV2Plugin::maker() const
915 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
919 LV2Plugin::num_ports() const
921 return lilv_plugin_get_num_ports(_impl->plugin);
925 LV2Plugin::parameter_count() const
927 return lilv_plugin_get_num_ports(_impl->plugin);
931 LV2Plugin::default_value(uint32_t port)
933 return _defaults[port];
937 LV2Plugin::port_symbol(uint32_t index) const
939 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
941 error << name() << ": Invalid port index " << index << endmsg;
944 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
945 return lilv_node_as_string(sym);
949 LV2Plugin::port_index (const char* symbol) const
951 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
952 if (i != _port_indices.end()) {
955 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
961 LV2Plugin::set_parameter(uint32_t which, float val)
963 DEBUG_TRACE(DEBUG::LV2, string_compose(
964 "%1 set parameter %2 to %3\n", name(), which, val));
966 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
967 if (get_parameter (which) == val) {
971 _shadow_data[which] = val;
973 warning << string_compose(
974 _("Illegal parameter number used with plugin \"%1\". "
975 "This is a bug in either %2 or the LV2 plugin <%3>"),
976 name(), PROGRAM_NAME, unique_id()) << endmsg;
979 Plugin::set_parameter(which, val);
983 LV2Plugin::get_parameter(uint32_t which) const
985 if (parameter_is_input(which)) {
986 return (float)_shadow_data[which];
988 return (float)_control_data[which];
994 LV2Plugin::get_docs() const
996 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
998 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
999 lilv_nodes_free(comments);
1007 LV2Plugin::get_parameter_docs(uint32_t which) const
1009 LilvNodes* comments = lilv_port_get_value(
1011 lilv_plugin_get_port_by_index(_impl->plugin, which),
1012 _world.rdfs_comment);
1015 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1016 lilv_nodes_free(comments);
1024 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1027 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1028 if (parameter_is_control(x)) {
1040 LV2Plugin::extension_data(const char* uri) const
1042 return lilv_instance_get_extension_data(_impl->instance, uri);
1046 LV2Plugin::c_plugin()
1048 return _impl->plugin;
1054 return (const void*)_impl->ui;
1058 LV2Plugin::c_ui_type()
1060 return (const void*)_impl->ui_type;
1063 /** Directory for all plugin state. */
1065 LV2Plugin::plugin_dir() const
1067 if (!_plugin_state_dir.empty ()){
1068 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1070 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1074 /** Directory for files created by the plugin (except during save). */
1076 LV2Plugin::scratch_dir() const
1078 return Glib::build_filename(plugin_dir(), "scratch");
1081 /** Directory for snapshots of files in the scratch directory. */
1083 LV2Plugin::file_dir() const
1085 return Glib::build_filename(plugin_dir(), "files");
1088 /** Directory to save state snapshot version @c num into. */
1090 LV2Plugin::state_dir(unsigned num) const
1092 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1095 /** Implementation of state:makePath for files created at instantiation time.
1096 * Note this is not used for files created at save time (Lilv deals with that).
1099 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1102 LV2Plugin* me = (LV2Plugin*)handle;
1103 if (me->_insert_id == PBD::ID("0")) {
1104 warning << string_compose(
1105 "File path \"%1\" requested but LV2 %2 has no insert ID",
1106 path, me->name()) << endmsg;
1107 return g_strdup(path);
1110 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1111 const std::string dirname = Glib::path_get_dirname(abs_path);
1112 g_mkdir_with_parents(dirname.c_str(), 0744);
1114 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1117 return g_strndup(abs_path.c_str(), abs_path.length());
1121 LV2Plugin::add_state(XMLNode* root) const
1123 assert(_insert_id != PBD::ID("0"));
1127 LocaleGuard lg(X_("C"));
1129 for (uint32_t i = 0; i < parameter_count(); ++i) {
1130 if (parameter_is_input(i) && parameter_is_control(i)) {
1131 child = new XMLNode("Port");
1132 child->add_property("symbol", port_symbol(i));
1133 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1134 child->add_property("value", string(buf));
1135 root->add_child_nocopy(*child);
1139 if (!_plugin_state_dir.empty()) {
1140 root->add_property("template-dir", _plugin_state_dir);
1143 if (_has_state_interface) {
1144 // Provisionally increment state version and create directory
1145 const std::string new_dir = state_dir(++_state_version);
1146 g_mkdir_with_parents(new_dir.c_str(), 0744);
1148 LilvState* state = lilv_state_new_from_instance(
1151 _uri_map.urid_map(),
1152 scratch_dir().c_str(),
1154 _session.externals_dir().c_str(),
1157 const_cast<LV2Plugin*>(this),
1161 if (!_plugin_state_dir.empty()
1163 || !lilv_state_equals(state, _impl->state)) {
1164 lilv_state_save(_world.world,
1165 _uri_map.urid_map(),
1166 _uri_map.urid_unmap(),
1172 if (_plugin_state_dir.empty()) {
1173 // normal session save
1174 lilv_state_free(_impl->state);
1175 _impl->state = state;
1177 // template save (dedicated state-dir)
1178 lilv_state_free(state);
1181 // State is identical, decrement version and nuke directory
1182 lilv_state_free(state);
1183 PBD::remove_directory(new_dir);
1187 root->add_property("state-dir", string_compose("state%1", _state_version));
1191 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1193 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1195 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1197 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1198 lilv_nodes_free(vs);
1205 LV2Plugin::find_presets()
1207 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1208 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1209 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1211 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1212 LILV_FOREACH(nodes, i, presets) {
1213 const LilvNode* preset = lilv_nodes_get(presets, i);
1214 lilv_world_load_resource(_world.world, preset);
1215 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1216 bool userpreset = true; // TODO
1218 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1219 Plugin::PresetRecord(
1220 lilv_node_as_string(preset),
1221 lilv_node_as_string(name),
1223 lilv_node_free(name);
1225 warning << string_compose(
1226 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1227 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1228 lilv_node_as_string(preset)) << endmsg;
1231 lilv_nodes_free(presets);
1233 lilv_node_free(rdfs_label);
1234 lilv_node_free(pset_Preset);
1235 lilv_node_free(lv2_appliesTo);
1239 set_port_value(const char* port_symbol,
1245 LV2Plugin* self = (LV2Plugin*)user_data;
1246 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1247 return; // TODO: Support non-float ports
1250 const uint32_t port_index = self->port_index(port_symbol);
1251 if (port_index != (uint32_t)-1) {
1252 self->set_parameter(port_index, *(const float*)value);
1257 LV2Plugin::load_preset(PresetRecord r)
1259 LilvWorld* world = _world.world;
1260 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1261 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1264 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1265 lilv_state_free(state);
1266 Plugin::load_preset(r);
1269 lilv_node_free(pset);
1274 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1279 LV2Plugin *plugin = (LV2Plugin *) user_data;
1281 uint32_t index = plugin->port_index(port_symbol);
1282 if (index != (uint32_t) -1) {
1283 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1285 *size = sizeof(float);
1286 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1287 value = &plugin->_shadow_data[index];
1299 LV2Plugin::do_save_preset(string name)
1301 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1302 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1303 const string base_name = legalize_for_uri(name);
1304 const string file_name = base_name + ".ttl";
1305 const string bundle = Glib::build_filename(
1306 Glib::get_home_dir(),
1307 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1309 #ifdef HAVE_LILV_0_21_3
1310 /* delete reference to old preset (if any) */
1311 const PresetRecord* r = preset_by_label(name);
1313 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1315 lilv_world_unload_resource (_world.world, pset);
1316 lilv_node_free(pset);
1321 LilvState* state = lilv_state_new_from_instance(
1324 _uri_map.urid_map(),
1325 scratch_dir().c_str(), // file_dir
1326 bundle.c_str(), // copy_dir
1327 bundle.c_str(), // link_dir
1328 bundle.c_str(), // save_dir
1329 lv2plugin_get_port_value, // get_value
1330 (void*)this, // user_data
1331 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1332 _features // features
1335 lilv_state_set_label(state, name.c_str());
1337 _world.world, // world
1338 _uri_map.urid_map(), // map
1339 _uri_map.urid_unmap(), // unmap
1341 NULL, // uri (NULL = use file URI)
1342 bundle.c_str(), // dir
1343 file_name.c_str() // filename
1346 lilv_state_free(state);
1348 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1349 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1350 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1351 #ifdef HAVE_LILV_0_21_3
1352 lilv_world_unload_resource(_world.world, node_preset);
1353 lilv_world_unload_bundle(_world.world, node_bundle);
1355 lilv_world_load_bundle(_world.world, node_bundle);
1356 lilv_world_load_resource(_world.world, node_preset);
1357 lilv_node_free(node_bundle);
1358 lilv_node_free(node_preset);
1359 lilv_node_free(plug_name);
1364 LV2Plugin::do_remove_preset(string name)
1366 #ifdef HAVE_LILV_0_21_3
1367 /* Look up preset record by label (FIXME: ick, label as ID) */
1368 const PresetRecord* r = preset_by_label(name);
1373 /* Load a LilvState for the preset. */
1374 LilvWorld* world = _world.world;
1375 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1376 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1378 lilv_node_free(pset);
1382 /* Unload preset from world. */
1383 lilv_world_unload_resource(world, pset);
1385 /* Delete it from the file system. This will remove the preset file and the entry
1386 from the manifest. If this results in an empty manifest (i.e. the
1387 preset is the only thing in the bundle), then the bundle is removed. */
1388 lilv_state_delete(world, state);
1390 lilv_state_free(state);
1391 lilv_node_free(pset);
1393 /* Without lilv_state_delete(), we could delete the preset file, but this
1394 would leave a broken bundle/manifest around, so the preset would still
1395 be visible, but broken. Naively deleting a bundle is too dangerous, so
1396 we simply do not support preset deletion with older Lilv */
1400 LV2Plugin::has_editor() const
1402 return _impl->ui != NULL;
1406 LV2Plugin::has_message_output() const
1408 for (uint32_t i = 0; i < num_ports(); ++i) {
1409 if ((_port_flags[i] & PORT_SEQUENCE) &&
1410 (_port_flags[i] & PORT_OUTPUT)) {
1418 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1422 const uint8_t* body)
1424 const uint32_t buf_size = sizeof(UIMessage) + size;
1425 vector<uint8_t> buf(buf_size);
1427 UIMessage* msg = (UIMessage*)&buf[0];
1429 msg->protocol = protocol;
1431 memcpy(msg + 1, body, size);
1433 return (dest->write(&buf[0], buf_size) == buf_size);
1437 LV2Plugin::write_from_ui(uint32_t index,
1440 const uint8_t* body)
1443 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1444 /* buffer data communication from plugin UI to plugin instance.
1445 * this buffer needs to potentially hold
1446 * (port's minimumSize) * (audio-periods) / (UI-periods)
1449 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1450 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1451 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1453 * it is NOT safe to overflow (msg.size will be misinterpreted)
1455 uint32_t bufsiz = 32768;
1456 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1457 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1459 rbs = max((size_t) bufsiz * 8, rbs);
1460 _from_ui = new RingBuffer<uint8_t>(rbs);
1463 if (!write_to(_from_ui, index, protocol, size, body)) {
1464 error << "Error writing from UI to plugin" << endmsg;
1471 LV2Plugin::write_to_ui(uint32_t index,
1474 const uint8_t* body)
1476 if (!write_to(_to_ui, index, protocol, size, body)) {
1477 error << "Error writing from plugin to UI" << endmsg;
1484 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1486 switch (value.type()) {
1487 case Variant::NOTHING:
1489 case Variant::BEATS:
1490 // No atom type for this, just forge a double
1491 lv2_atom_forge_double(forge, value.get_beats().to_double());
1494 lv2_atom_forge_bool(forge, value.get_bool());
1496 case Variant::DOUBLE:
1497 lv2_atom_forge_double(forge, value.get_double());
1499 case Variant::FLOAT:
1500 lv2_atom_forge_float(forge, value.get_float());
1503 lv2_atom_forge_int(forge, value.get_int());
1506 lv2_atom_forge_long(forge, value.get_long());
1509 lv2_atom_forge_path(
1510 forge, value.get_path().c_str(), value.get_path().size());
1512 case Variant::STRING:
1513 lv2_atom_forge_string(
1514 forge, value.get_string().c_str(), value.get_string().size());
1518 forge, value.get_uri().c_str(), value.get_uri().size());
1523 /** Get a variant type from a URI, return false iff no match found. */
1525 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1527 if (uri == LV2_ATOM__Bool) {
1528 type = Variant::BOOL;
1529 } else if (uri == LV2_ATOM__Double) {
1530 type = Variant::DOUBLE;
1531 } else if (uri == LV2_ATOM__Float) {
1532 type = Variant::FLOAT;
1533 } else if (uri == LV2_ATOM__Int) {
1534 type = Variant::INT;
1535 } else if (uri == LV2_ATOM__Long) {
1536 type = Variant::LONG;
1537 } else if (uri == LV2_ATOM__Path) {
1538 type = Variant::PATH;
1539 } else if (uri == LV2_ATOM__String) {
1540 type = Variant::STRING;
1541 } else if (uri == LV2_ATOM__URI) {
1542 type = Variant::URI;
1550 LV2Plugin::set_property(uint32_t key, const Variant& value)
1552 if (_patch_port_in_index == (uint32_t)-1) {
1553 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1555 } else if (value.type() == Variant::NOTHING) {
1556 error << "LV2: set_property called with void value" << endmsg;
1560 // Set up forge to write to temporary buffer on the stack
1561 LV2_Atom_Forge* forge = &_impl->ui_forge;
1562 LV2_Atom_Forge_Frame frame;
1563 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1565 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1567 // Serialize patch:Set message to set property
1568 #ifdef HAVE_LV2_1_10_0
1569 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1570 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1571 lv2_atom_forge_urid(forge, key);
1572 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1574 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1575 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1576 lv2_atom_forge_urid(forge, key);
1577 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1580 forge_variant(forge, value);
1582 // Write message to UI=>Plugin ring
1583 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1584 write_from_ui(_patch_port_in_index,
1585 _uri_map.urids.atom_eventTransfer,
1586 lv2_atom_total_size(atom),
1587 (const uint8_t*)atom);
1590 const ParameterDescriptor&
1591 LV2Plugin::get_property_descriptor(uint32_t id) const
1593 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1594 if (p != _property_descriptors.end()) {
1597 return Plugin::get_property_descriptor(id);
1601 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1603 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1604 desc.unit = ParameterDescriptor::MIDI_NOTE;
1605 } else if (lilv_nodes_contains(units, _world.units_db)) {
1606 desc.unit = ParameterDescriptor::DB;
1607 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1608 desc.unit = ParameterDescriptor::HZ;
1610 if (lilv_nodes_size(units) > 0) {
1611 const LilvNode* unit = lilv_nodes_get_first(units);
1612 LilvNode* render = get_value(lworld, unit, _world.units_render);
1614 desc.print_fmt = lilv_node_as_string(render);
1615 lilv_node_free(render);
1621 load_parameter_descriptor(LV2World& world,
1622 ParameterDescriptor& desc,
1623 Variant::Type datatype,
1624 const LilvNode* subject)
1626 LilvWorld* lworld = _world.world;
1627 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1628 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1629 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1630 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1631 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1633 desc.label = lilv_node_as_string(label);
1635 if (def && lilv_node_is_float(def)) {
1636 desc.normal = lilv_node_as_float(def);
1638 if (minimum && lilv_node_is_float(minimum)) {
1639 desc.lower = lilv_node_as_float(minimum);
1641 if (maximum && lilv_node_is_float(maximum)) {
1642 desc.upper = lilv_node_as_float(maximum);
1644 load_parameter_descriptor_units(lworld, desc, units);
1645 desc.datatype = datatype;
1646 desc.toggled |= datatype == Variant::BOOL;
1647 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1648 desc.update_steps();
1650 lilv_nodes_free(units);
1651 lilv_node_free(label);
1652 lilv_node_free(def);
1653 lilv_node_free(minimum);
1654 lilv_node_free(maximum);
1658 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1660 LilvWorld* lworld = _world.world;
1661 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1662 LilvNodes* properties = lilv_world_find_nodes(
1663 lworld, subject, _world.patch_writable, NULL);
1664 LILV_FOREACH(nodes, p, properties) {
1665 // Get label and range
1666 const LilvNode* prop = lilv_nodes_get(properties, p);
1667 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1669 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1670 lilv_node_as_uri(prop)) << endmsg;
1674 // Convert range to variant type (TODO: support for multiple range types)
1675 Variant::Type datatype;
1676 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1677 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1678 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1682 // Add description to result
1683 ParameterDescriptor desc;
1684 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1685 desc.datatype = datatype;
1686 load_parameter_descriptor(_world, desc, datatype, prop);
1687 descs.insert(std::make_pair(desc.key, desc));
1689 lilv_node_free(range);
1691 lilv_nodes_free(properties);
1695 LV2Plugin::announce_property_values()
1697 if (_patch_port_in_index == (uint32_t)-1) {
1701 // Set up forge to write to temporary buffer on the stack
1702 LV2_Atom_Forge* forge = &_impl->ui_forge;
1703 LV2_Atom_Forge_Frame frame;
1704 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1706 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1708 // Serialize patch:Get message with no subject (implicitly plugin instance)
1709 #ifdef HAVE_LV2_1_10_0
1710 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1712 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1715 // Write message to UI=>Plugin ring
1716 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1717 write_from_ui(_patch_port_in_index,
1718 _uri_map.urids.atom_eventTransfer,
1719 lv2_atom_total_size(atom),
1720 (const uint8_t*)atom);
1724 LV2Plugin::enable_ui_emission()
1727 /* see note in LV2Plugin::write_from_ui() */
1728 uint32_t bufsiz = 32768;
1729 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1730 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1732 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1733 rbs = max((size_t) bufsiz * 8, rbs);
1734 _to_ui = new RingBuffer<uint8_t>(rbs);
1739 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1745 uint32_t read_space = _to_ui->read_space();
1746 while (read_space > sizeof(UIMessage)) {
1748 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1749 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1752 vector<uint8_t> body(msg.size);
1753 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1754 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1758 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1760 read_space -= sizeof(msg) + msg.size;
1765 LV2Plugin::work(uint32_t size, const void* data)
1767 return _impl->work_iface->work(
1768 _impl->instance->lv2_handle, work_respond, this, size, data);
1772 LV2Plugin::work_response(uint32_t size, const void* data)
1774 return _impl->work_iface->work_response(
1775 _impl->instance->lv2_handle, size, data);
1779 LV2Plugin::set_insert_id(PBD::ID id)
1781 if (_insert_id == "0") {
1783 } else if (_insert_id != id) {
1784 lilv_state_free(_impl->state);
1785 _impl->state = NULL;
1791 LV2Plugin::set_state_dir (const std::string& d)
1793 _plugin_state_dir = d;
1797 LV2Plugin::set_state(const XMLNode& node, int version)
1800 const XMLProperty* prop;
1801 XMLNodeConstIterator iter;
1806 LocaleGuard lg(X_("C"));
1808 if (node.name() != state_node_name()) {
1809 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1813 #ifndef NO_PLUGIN_STATE
1815 if (version < 3000) {
1816 nodes = node.children("port");
1818 nodes = node.children("Port");
1821 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1825 if ((prop = child->property("symbol")) != 0) {
1826 sym = prop->value().c_str();
1828 warning << _("LV2: port has no symbol, ignored") << endmsg;
1832 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1834 if (i != _port_indices.end()) {
1835 port_id = i->second;
1837 warning << _("LV2: port has unknown index, ignored") << endmsg;
1841 if ((prop = child->property("value")) != 0) {
1842 value = prop->value().c_str();
1844 warning << _("LV2: port has no value, ignored") << endmsg;
1848 set_parameter(port_id, atof(value));
1851 if ((prop = node.property("template-dir")) != 0) {
1852 set_state_dir (prop->value ());
1856 if ((prop = node.property("state-dir")) != 0) {
1857 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1858 error << string_compose(
1859 "LV2: failed to parse state version from \"%1\"",
1860 prop->value()) << endmsg;
1863 std::string state_file = Glib::build_filename(
1865 Glib::build_filename(prop->value(), "state.ttl"));
1867 LilvState* state = lilv_state_new_from_file(
1868 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1870 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1871 lilv_state_free(_impl->state);
1872 _impl->state = state;
1875 if (!_plugin_state_dir.empty ()) {
1876 // force save with session, next time (increment counter)
1877 lilv_state_free (_impl->state);
1878 _impl->state = NULL;
1882 latency_compute_run();
1885 return Plugin::set_state(node, version);
1889 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1891 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1893 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1898 LilvNodes* portunits;
1899 LilvNode *def, *min, *max;
1900 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1901 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1903 // TODO: Once we can rely on lilv 0.18.0 being present,
1904 // load_parameter_descriptor() can be used for ports as well
1905 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1906 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1907 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1908 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1909 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1910 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1911 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1912 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1913 load_parameter_descriptor_units(_world.world, desc, portunits);
1915 if (desc.sr_dependent) {
1916 desc.lower *= _session.frame_rate ();
1917 desc.upper *= _session.frame_rate ();
1920 desc.min_unbound = false; // TODO: LV2 extension required
1921 desc.max_unbound = false; // TODO: LV2 extension required
1923 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1924 desc.scale_points = get_scale_points(which);
1926 desc.update_steps();
1928 lilv_node_free(def);
1929 lilv_node_free(min);
1930 lilv_node_free(max);
1931 lilv_nodes_free(portunits);
1936 Plugin::IOPortDescription
1937 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
1939 PortFlags match = 0;
1941 case DataType::AUDIO:
1944 case DataType::MIDI:
1945 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
1948 return Plugin::IOPortDescription ("?");
1952 match |= PORT_INPUT;
1954 match |= PORT_OUTPUT;
1958 uint32_t idx = UINT32_MAX;
1960 uint32_t const num_ports = parameter_count();
1961 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1962 PortFlags flags = _port_flags[port_index];
1963 if ((flags & match) == match) {
1970 if (idx == UINT32_MAX) {
1971 return Plugin::IOPortDescription ("?");
1974 LilvNode* name = lilv_port_get_name(_impl->plugin,
1975 lilv_plugin_get_port_by_index(_impl->plugin, idx));
1976 Plugin::IOPortDescription iod (lilv_node_as_string (name));
1977 lilv_node_free(name);
1979 if (lilv_port_has_property(_impl->plugin,
1980 lilv_plugin_get_port_by_index(_impl->plugin, idx), _world.lv2_isSideChain)) {
1981 iod.is_sidechain = true;
1987 LV2Plugin::describe_parameter(Evoral::Parameter which)
1989 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1991 if (lilv_port_has_property(_impl->plugin,
1992 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1993 return X_("hidden");
1996 if (lilv_port_has_property(_impl->plugin,
1997 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1998 return X_("hidden");
2001 if (lilv_port_has_property(_impl->plugin,
2002 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2003 return X_("latency");
2006 LilvNode* name = lilv_port_get_name(_impl->plugin,
2007 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2008 string ret(lilv_node_as_string(name));
2009 lilv_node_free(name);
2017 LV2Plugin::max_latency () const
2019 return _max_latency;
2023 LV2Plugin::signal_latency() const
2025 if (_latency_control_port) {
2026 return (framecnt_t)floor(*_latency_control_port);
2032 set<Evoral::Parameter>
2033 LV2Plugin::automatable() const
2035 set<Evoral::Parameter> ret;
2037 for (uint32_t i = 0; i < parameter_count(); ++i) {
2038 if (parameter_is_input(i) && parameter_is_control(i)) {
2039 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2043 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2044 p != _property_descriptors.end();
2046 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2052 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2054 if ((_port_flags[i] & PORT_CTRLED)) {
2055 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2059 LV2Plugin::AutomationCtrlPtr
2060 LV2Plugin::get_automation_control (uint32_t i)
2062 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2063 return AutomationCtrlPtr ();
2065 return _ctrl_map[i];
2069 LV2Plugin::activate()
2071 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2073 if (!_was_activated) {
2074 lilv_instance_activate(_impl->instance);
2075 _was_activated = true;
2080 LV2Plugin::deactivate()
2082 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2084 if (_was_activated) {
2085 lilv_instance_deactivate(_impl->instance);
2086 _was_activated = false;
2091 LV2Plugin::cleanup()
2093 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2096 lilv_instance_free(_impl->instance);
2097 _impl->instance = NULL;
2101 LV2Plugin::allocate_atom_event_buffers()
2103 /* reserve local scratch buffers for ATOM event-queues */
2104 const LilvPlugin* p = _impl->plugin;
2106 /* count non-MIDI atom event-ports
2107 * TODO: nicely ask drobilla to make a lilv_ call for that
2109 int count_atom_out = 0;
2110 int count_atom_in = 0;
2111 int minimumSize = 32768; // TODO use a per-port minimum-size
2112 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2113 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2114 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2115 LilvNodes* buffer_types = lilv_port_get_value(
2116 p, port, _world.atom_bufferType);
2117 LilvNodes* atom_supports = lilv_port_get_value(
2118 p, port, _world.atom_supports);
2120 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
2121 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
2122 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2125 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2128 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2129 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2130 if (min_size && lilv_node_is_int(min_size)) {
2131 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2133 lilv_nodes_free(min_size_v);
2135 lilv_nodes_free(buffer_types);
2136 lilv_nodes_free(atom_supports);
2140 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2141 name(), count_atom_in, count_atom_out));
2143 const int total_atom_buffers = (count_atom_in + count_atom_out);
2144 if (_atom_ev_buffers || total_atom_buffers == 0) {
2148 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
2149 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2150 for (int i = 0; i < total_atom_buffers; ++i ) {
2151 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2152 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2154 _atom_ev_buffers[total_atom_buffers] = 0;
2158 /** Write an ardour position/time/tempo/meter as an LV2 event.
2159 * @return true on success.
2162 write_position(LV2_Atom_Forge* forge,
2164 const TempoMetric& t,
2165 Timecode::BBT_Time& bbt,
2167 framepos_t position,
2170 const URIMap::URIDs& urids = URIMap::instance().urids;
2172 uint8_t pos_buf[256];
2173 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2174 LV2_Atom_Forge_Frame frame;
2175 #ifdef HAVE_LV2_1_10_0
2176 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2177 lv2_atom_forge_key(forge, urids.time_frame);
2178 lv2_atom_forge_long(forge, position);
2179 lv2_atom_forge_key(forge, urids.time_speed);
2180 lv2_atom_forge_float(forge, speed);
2181 lv2_atom_forge_key(forge, urids.time_barBeat);
2182 lv2_atom_forge_float(forge, bbt.beats - 1 +
2183 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2184 lv2_atom_forge_key(forge, urids.time_bar);
2185 lv2_atom_forge_long(forge, bbt.bars - 1);
2186 lv2_atom_forge_key(forge, urids.time_beatUnit);
2187 lv2_atom_forge_int(forge, t.meter().note_divisor());
2188 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2189 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2190 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2191 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2193 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2194 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2195 lv2_atom_forge_long(forge, position);
2196 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2197 lv2_atom_forge_float(forge, speed);
2198 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2199 lv2_atom_forge_float(forge, bbt.beats - 1 +
2200 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2201 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2202 lv2_atom_forge_long(forge, bbt.bars - 1);
2203 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2204 lv2_atom_forge_int(forge, t.meter().note_divisor());
2205 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2206 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2207 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2208 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2211 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2212 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2213 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2214 (const uint8_t*)(atom + 1));
2218 LV2Plugin::connect_and_run(BufferSet& bufs,
2219 ChanMapping in_map, ChanMapping out_map,
2220 pframes_t nframes, framecnt_t offset)
2222 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2223 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2225 cycles_t then = get_cycles();
2227 TempoMap& tmap = _session.tempo_map();
2228 Metrics::const_iterator metric_i = tmap.metrics_end();
2229 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2231 if (_freewheel_control_port) {
2232 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2235 if (_bpm_control_port) {
2236 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2240 if (_can_write_automation && _session.transport_frame() != _next_cycle_start) {
2241 // add guard-points after locating
2242 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2243 i->second->guard = true;
2248 ChanCount bufs_count;
2249 bufs_count.set(DataType::AUDIO, 1);
2250 bufs_count.set(DataType::MIDI, 1);
2251 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2252 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2253 uint32_t const num_ports = parameter_count();
2254 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2256 uint32_t audio_in_index = 0;
2257 uint32_t audio_out_index = 0;
2258 uint32_t midi_in_index = 0;
2259 uint32_t midi_out_index = 0;
2260 uint32_t atom_port_index = 0;
2261 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2263 uint32_t index = nil_index;
2264 PortFlags flags = _port_flags[port_index];
2266 if (flags & PORT_AUDIO) {
2267 if (flags & PORT_INPUT) {
2268 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2270 ? bufs.get_audio(index).data(offset)
2271 : silent_bufs.get_audio(0).data(offset);
2273 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2275 ? bufs.get_audio(index).data(offset)
2276 : scratch_bufs.get_audio(0).data(offset);
2278 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2279 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2280 be necessary, but the mapping is illegal in some cases. Ideally
2281 that should be fixed, but this is easier...
2283 if (flags & PORT_MIDI) {
2284 if (flags & PORT_INPUT) {
2285 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2287 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2289 if (valid && bufs.count().n_midi() > index) {
2290 /* Note, ensure_lv2_bufsize() is not RT safe!
2291 * However free()/alloc() is only called if a
2292 * plugin requires a rsz:minimumSize buffersize
2293 * and the existing buffer if smaller.
2295 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2296 _ev_buffers[port_index] = bufs.get_lv2_midi(
2297 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2299 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2300 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2301 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2305 if (valid && (flags & PORT_INPUT)) {
2306 Timecode::BBT_Time bbt;
2307 if ((flags & PORT_POSITION)) {
2308 if (_session.transport_frame() != _next_cycle_start ||
2309 _session.transport_speed() != _next_cycle_speed) {
2310 // Transport has changed, write position at cycle start
2311 tmap.bbt_time(_session.transport_frame(), bbt);
2312 write_position(&_impl->forge, _ev_buffers[port_index],
2313 tmetric, bbt, _session.transport_speed(),
2314 _session.transport_frame(), 0);
2318 // Get MIDI iterator range (empty range if no MIDI)
2319 MidiBuffer::iterator m = (index != nil_index)
2320 ? bufs.get_midi(index).begin()
2321 : silent_bufs.get_midi(0).end();
2322 MidiBuffer::iterator m_end = (index != nil_index)
2323 ? bufs.get_midi(index).end()
2326 // Now merge MIDI and any transport events into the buffer
2327 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2328 const framepos_t tend = _session.transport_frame() + nframes;
2330 while (m != m_end || (metric_i != tmap.metrics_end() &&
2331 (*metric_i)->frame() < tend)) {
2332 MetricSection* metric = (metric_i != tmap.metrics_end())
2334 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2335 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2336 if (ev.time() < nframes) {
2337 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2338 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2342 tmetric.set_metric(metric);
2343 bbt = metric->start();
2344 write_position(&_impl->forge, _ev_buffers[port_index],
2345 tmetric, bbt, _session.transport_speed(),
2347 metric->frame() - _session.transport_frame());
2351 } else if (!valid) {
2352 // Nothing we understand or care about, connect to scratch
2353 // see note for midi-buffer size above
2354 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2355 0, _port_minimumSize[port_index]);
2356 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2357 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2360 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2362 continue; // Control port, leave buffer alone
2364 lilv_instance_connect_port(_impl->instance, port_index, buf);
2367 // Read messages from UI and push into appropriate buffers
2369 uint32_t read_space = _from_ui->read_space();
2370 while (read_space > sizeof(UIMessage)) {
2372 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2373 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2376 vector<uint8_t> body(msg.size);
2377 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2378 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2381 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2382 LV2_Evbuf* buf = _ev_buffers[msg.index];
2383 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2384 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2385 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2386 (const uint8_t*)(atom + 1))) {
2387 error << "Failed to write data to LV2 event buffer\n";
2390 error << "Received unknown message type from UI" << endmsg;
2392 read_space -= sizeof(UIMessage) + msg.size;
2399 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2400 PortFlags flags = _port_flags[port_index];
2403 /* TODO ask drobilla about comment
2404 * "Make Ardour event buffers generic so plugins can communicate"
2405 * in libs/ardour/buffer_set.cc:310
2407 * ideally the user could choose which of the following two modes
2408 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2410 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2411 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2412 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2413 * for quite a while at least ;)
2415 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2416 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2417 const uint32_t buf_index = out_map.get(
2418 DataType::MIDI, midi_out_index++, &valid);
2420 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2423 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2424 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2425 const uint32_t buf_index = out_map.get(
2426 DataType::MIDI, midi_out_index++, &valid);
2428 bufs.flush_lv2_midi(true, buf_index);
2432 // Write messages to UI
2433 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2434 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2435 LV2_Evbuf* buf = _ev_buffers[port_index];
2436 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2437 lv2_evbuf_is_valid(i);
2438 i = lv2_evbuf_next(i)) {
2439 uint32_t frames, subframes, type, size;
2441 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2444 // Intercept Automation Write Events
2445 if ((flags & PORT_AUTOCTRL)) {
2446 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2447 if (atom->type == _uri_map.urids.atom_Blank ||
2448 atom->type == _uri_map.urids.atom_Object) {
2449 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2450 if (obj->body.otype == _uri_map.urids.auto_event) {
2451 // only if transport_rolling ??
2452 const LV2_Atom* parameter = NULL;
2453 const LV2_Atom* value = NULL;
2454 lv2_atom_object_get(obj,
2455 _uri_map.urids.auto_parameter, ¶meter,
2456 _uri_map.urids.auto_value, &value,
2458 if (parameter && value) {
2459 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2460 const float v = ((const LV2_Atom_Float*)value)->body;
2461 // -> add automation event..
2462 AutomationCtrlPtr c = get_automation_control (p);
2463 if (c && c->ac->automation_state() == Touch) {
2466 c->ac->list()->add (_session.transport_frame() + frames, v, true, true);
2468 c->ac->set_double (v, _session.transport_frame() + frames, true);
2473 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2474 // TODO optional arguments, for now we assume the plugin
2475 // writes automation for its own inputs
2476 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2477 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2478 i->second->ac->set_automation_state (Touch);
2481 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2482 // set [touched] parameters to "play" ??
2484 else if (obj->body.otype == _uri_map.urids.auto_start) {
2485 const LV2_Atom* parameter = NULL;
2486 lv2_atom_object_get(obj,
2487 _uri_map.urids.auto_parameter, ¶meter,
2490 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2491 AutomationCtrlPtr c = get_automation_control (p);
2493 c->ac->start_touch (_session.transport_frame());
2498 else if (obj->body.otype == _uri_map.urids.auto_end) {
2499 const LV2_Atom* parameter = NULL;
2500 lv2_atom_object_get(obj,
2501 _uri_map.urids.auto_parameter, ¶meter,
2504 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2505 AutomationCtrlPtr c = get_automation_control (p);
2507 c->ac->stop_touch (true, _session.transport_frame());
2515 // Intercept patch change messages to emit PropertyChanged signal
2516 if ((flags & PORT_PATCHMSG)) {
2517 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2518 if (atom->type == _uri_map.urids.atom_Blank ||
2519 atom->type == _uri_map.urids.atom_Object) {
2520 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2521 if (obj->body.otype == _uri_map.urids.patch_Set) {
2522 const LV2_Atom* property = NULL;
2523 const LV2_Atom* value = NULL;
2524 lv2_atom_object_get(obj,
2525 _uri_map.urids.patch_property, &property,
2526 _uri_map.urids.patch_value, &value,
2529 if (property && value &&
2530 property->type == _uri_map.urids.atom_URID &&
2531 value->type == _uri_map.urids.atom_Path) {
2532 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2533 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2535 // Emit PropertyChanged signal for UI
2536 // TODO: This should emit the control's Changed signal
2537 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2539 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2545 if (!_to_ui) continue;
2546 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2547 size + sizeof(LV2_Atom),
2548 data - sizeof(LV2_Atom));
2553 cycles_t now = get_cycles();
2554 set_cycles((uint32_t)(now - then));
2556 // Update expected transport information for next cycle so we can detect changes
2557 _next_cycle_speed = _session.transport_speed();
2558 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2560 if (_latency_control_port) {
2561 framecnt_t new_latency = signal_latency ();
2562 if (_current_latency != new_latency) {
2563 LatencyChanged (_current_latency, new_latency); /* EMIT SIGNAL */
2565 _current_latency = new_latency;
2571 LV2Plugin::parameter_is_control(uint32_t param) const
2573 assert(param < _port_flags.size());
2574 return _port_flags[param] & PORT_CONTROL;
2578 LV2Plugin::parameter_is_audio(uint32_t param) const
2580 assert(param < _port_flags.size());
2581 return _port_flags[param] & PORT_AUDIO;
2585 LV2Plugin::parameter_is_event(uint32_t param) const
2587 assert(param < _port_flags.size());
2588 return _port_flags[param] & PORT_EVENT;
2592 LV2Plugin::parameter_is_output(uint32_t param) const
2594 assert(param < _port_flags.size());
2595 return _port_flags[param] & PORT_OUTPUT;
2599 LV2Plugin::parameter_is_input(uint32_t param) const
2601 assert(param < _port_flags.size());
2602 return _port_flags[param] & PORT_INPUT;
2606 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2609 if (param < parameter_count()) {
2610 snprintf(buf, len, "%.3f", get_parameter(param));
2617 boost::shared_ptr<ScalePoints>
2618 LV2Plugin::get_scale_points(uint32_t port_index) const
2620 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2621 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2623 boost::shared_ptr<ScalePoints> ret;
2628 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2630 LILV_FOREACH(scale_points, i, points) {
2631 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2632 const LilvNode* label = lilv_scale_point_get_label(p);
2633 const LilvNode* value = lilv_scale_point_get_value(p);
2634 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2635 ret->insert(make_pair(lilv_node_as_string(label),
2636 lilv_node_as_float(value)));
2640 lilv_scale_points_free(points);
2645 LV2Plugin::run(pframes_t nframes)
2647 uint32_t const N = parameter_count();
2648 for (uint32_t i = 0; i < N; ++i) {
2649 if (parameter_is_control(i) && parameter_is_input(i)) {
2650 _control_data[i] = _shadow_data[i];
2654 lilv_instance_run(_impl->instance, nframes);
2656 if (_impl->work_iface) {
2657 _worker->emit_responses();
2658 if (_impl->work_iface->end_run) {
2659 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2665 LV2Plugin::latency_compute_run()
2667 if (!_latency_control_port) {
2671 // Run the plugin so that it can set its latency parameter
2673 bool was_activated = _was_activated;
2676 uint32_t port_index = 0;
2677 uint32_t in_index = 0;
2678 uint32_t out_index = 0;
2680 // this is done in the main thread. non realtime.
2681 const framecnt_t bufsize = _engine.samples_per_cycle();
2682 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2684 memset(buffer, 0, sizeof(float) * bufsize);
2686 // FIXME: Ensure plugins can handle in-place processing
2690 while (port_index < parameter_count()) {
2691 if (parameter_is_audio(port_index)) {
2692 if (parameter_is_input(port_index)) {
2693 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2695 } else if (parameter_is_output(port_index)) {
2696 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2705 if (was_activated) {
2712 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2714 const LilvPort* port = NULL;
2715 LilvNode* designation = lilv_new_uri(_world.world, uri);
2716 port = lilv_plugin_get_port_by_designation(
2717 plugin, _world.lv2_InputPort, designation);
2718 lilv_node_free(designation);
2720 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2725 static bool lv2_filter (const string& str, void* /*arg*/)
2727 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2729 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2733 LV2World::LV2World()
2734 : world(lilv_world_new())
2735 , _bundle_checked(false)
2737 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2738 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2739 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2740 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2741 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2742 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2743 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2744 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2745 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2746 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2747 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2748 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2749 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2750 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2751 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
2752 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2753 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2754 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2755 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2756 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2757 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2758 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2759 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2760 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2761 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2762 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2763 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2764 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2765 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2766 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2767 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2768 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2769 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2770 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2771 units_render = lilv_new_uri(world, LV2_UNITS__render);
2772 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2773 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2774 units_db = lilv_new_uri(world, LV2_UNITS__db);
2775 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2776 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2778 lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2779 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
2780 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
2781 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
2783 #ifdef HAVE_LV2_1_2_0
2784 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2785 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2786 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2791 LV2World::~LV2World()
2796 #ifdef HAVE_LV2_1_2_0
2797 lilv_node_free(bufz_nominalBlockLength);
2798 lilv_node_free(bufz_fixedBlockLength);
2799 lilv_node_free(bufz_powerOf2BlockLength);
2802 lilv_node_free(lv2_noSampleAccurateCtrl);
2803 lilv_node_free(auto_can_write_automatation);
2804 lilv_node_free(auto_automation_control);
2805 lilv_node_free(auto_automation_controlled);
2807 lilv_node_free(patch_Message);
2808 lilv_node_free(patch_writable);
2809 lilv_node_free(units_hz);
2810 lilv_node_free(units_midiNote);
2811 lilv_node_free(units_db);
2812 lilv_node_free(units_unit);
2813 lilv_node_free(units_render);
2814 lilv_node_free(ui_externalkx);
2815 lilv_node_free(ui_external);
2816 lilv_node_free(ui_GtkUI);
2817 lilv_node_free(time_Position);
2818 lilv_node_free(rsz_minimumSize);
2819 lilv_node_free(rdfs_comment);
2820 lilv_node_free(rdfs_label);
2821 lilv_node_free(rdfs_range);
2822 lilv_node_free(midi_MidiEvent);
2823 lilv_node_free(lv2_enumeration);
2824 lilv_node_free(lv2_freewheeling);
2825 lilv_node_free(lv2_toggled);
2826 lilv_node_free(lv2_sampleRate);
2827 lilv_node_free(lv2_reportsLatency);
2828 lilv_node_free(lv2_integer);
2829 lilv_node_free(lv2_isSideChain);
2830 lilv_node_free(lv2_inPlaceBroken);
2831 lilv_node_free(lv2_OutputPort);
2832 lilv_node_free(lv2_InputPort);
2833 lilv_node_free(lv2_ControlPort);
2834 lilv_node_free(lv2_AudioPort);
2835 lilv_node_free(ext_notOnGUI);
2836 lilv_node_free(ext_logarithmic);
2837 lilv_node_free(ev_EventPort);
2838 lilv_node_free(atom_supports);
2839 lilv_node_free(atom_eventTransfer);
2840 lilv_node_free(atom_bufferType);
2841 lilv_node_free(atom_Sequence);
2842 lilv_node_free(atom_Chunk);
2843 lilv_node_free(atom_AtomPort);
2844 lilv_world_free(world);
2849 LV2World::load_bundled_plugins(bool verbose)
2851 if (!_bundle_checked) {
2853 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2856 vector<string> plugin_objects;
2857 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2858 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2859 #ifdef PLATFORM_WINDOWS
2860 string uri = "file:///" + *x + "/";
2862 string uri = "file://" + *x + "/";
2864 LilvNode *node = lilv_new_uri(world, uri.c_str());
2865 lilv_world_load_bundle(world, node);
2866 lilv_node_free(node);
2869 lilv_world_load_all(world);
2870 _bundle_checked = true;
2874 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2877 _plugin_uri = strdup(plugin_uri);
2880 LV2PluginInfo::~LV2PluginInfo()
2887 LV2PluginInfo::load(Session& session)
2891 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2892 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2893 if (!uri) { throw failed_constructor(); }
2894 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2895 if (!lp) { throw failed_constructor(); }
2896 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2897 lilv_node_free(uri);
2898 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2900 } catch (failed_constructor& err) {
2901 return PluginPtr((Plugin*)0);
2907 std::vector<Plugin::PresetRecord>
2908 LV2PluginInfo::get_presets (bool /*user_only*/) const
2910 std::vector<Plugin::PresetRecord> p;
2911 #ifndef NO_PLUGIN_STATE
2912 const LilvPlugin* lp = NULL;
2915 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2916 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2917 if (!uri) { throw failed_constructor(); }
2918 lp = lilv_plugins_get_by_uri(plugins, uri);
2919 if (!lp) { throw failed_constructor(); }
2920 lilv_node_free(uri);
2921 } catch (failed_constructor& err) {
2925 // see LV2Plugin::find_presets
2926 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
2927 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
2928 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
2930 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
2931 LILV_FOREACH(nodes, i, presets) {
2932 const LilvNode* preset = lilv_nodes_get(presets, i);
2933 lilv_world_load_resource(_world.world, preset);
2934 LilvNode* name = get_value(_world.world, preset, rdfs_label);
2935 bool userpreset = true; // TODO
2937 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
2938 lilv_node_free(name);
2941 lilv_nodes_free(presets);
2942 lilv_node_free(rdfs_label);
2943 lilv_node_free(pset_Preset);
2944 lilv_node_free(lv2_appliesTo);
2950 LV2PluginInfo::in_category (const std::string &c) const
2952 // TODO use untranslated lilv_plugin_get_class()
2953 // match gtk2_ardour/plugin_selector.cc
2954 if (category == c) {
2961 LV2PluginInfo::is_instrument () const
2963 if (category == "Instrument") {
2967 /* until we make sure that category remains untranslated in the lv2.ttl spec
2968 * and until most instruments also classify themselves as such, there's a 2nd check:
2970 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2978 LV2PluginInfo::discover()
2981 world.load_bundled_plugins();
2982 _world.load_bundled_plugins(true);
2984 PluginInfoList* plugs = new PluginInfoList;
2985 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2987 LILV_FOREACH(plugins, i, plugins) {
2988 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2989 const LilvNode* pun = lilv_plugin_get_uri(p);
2991 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2993 LilvNode* name = lilv_plugin_get_name(p);
2994 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2995 warning << "Ignoring invalid LV2 plugin "
2996 << lilv_node_as_string(lilv_plugin_get_uri(p))
3001 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3002 warning << string_compose(
3003 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3004 lilv_node_as_string(name)) << endmsg;
3005 lilv_node_free(name);
3009 #ifdef HAVE_LV2_1_2_0
3010 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3011 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3012 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3014 warning << string_compose(
3015 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3016 lilv_node_as_string(name)) << endmsg;
3017 lilv_nodes_free(required_features);
3018 lilv_node_free(name);
3021 lilv_nodes_free(required_features);
3026 info->name = string(lilv_node_as_string(name));
3027 lilv_node_free(name);
3028 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3030 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3031 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3032 info->category = lilv_node_as_string(label);
3034 LilvNode* author_name = lilv_plugin_get_author_name(p);
3035 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3036 lilv_node_free(author_name);
3038 info->path = "/NOPATH"; // Meaningless for LV2
3040 /* count atom-event-ports that feature
3041 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3043 * TODO: nicely ask drobilla to make a lilv_ call for that
3045 int count_midi_out = 0;
3046 int count_midi_in = 0;
3047 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3048 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3049 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3050 LilvNodes* buffer_types = lilv_port_get_value(
3051 p, port, world.atom_bufferType);
3052 LilvNodes* atom_supports = lilv_port_get_value(
3053 p, port, world.atom_supports);
3055 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3056 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3057 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3060 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3064 lilv_nodes_free(buffer_types);
3065 lilv_nodes_free(atom_supports);
3069 info->n_inputs.set_audio(
3070 lilv_plugin_get_num_ports_of_class(
3071 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3072 info->n_inputs.set_midi(
3073 lilv_plugin_get_num_ports_of_class(
3074 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3077 info->n_outputs.set_audio(
3078 lilv_plugin_get_num_ports_of_class(
3079 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3080 info->n_outputs.set_midi(
3081 lilv_plugin_get_num_ports_of_class(
3082 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3085 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3086 info->index = 0; // Meaningless for LV2
3088 plugs->push_back(info);