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;
368 _impl->block_length = _session.get_block_size();
370 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
371 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
372 _make_path_feature.URI = LV2_STATE__makePath;
373 _log_feature.URI = LV2_LOG__log;
374 _work_schedule_feature.URI = LV2_WORKER__schedule;
375 _work_schedule_feature.data = NULL;
376 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
377 _def_state_feature.data = NULL;
379 const LilvPlugin* plugin = _impl->plugin;
381 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
382 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
383 _has_state_interface =
384 // What plugins should have (lv2:extensionData state:Interface)
385 lilv_plugin_has_extension_data(plugin, state_iface_uri)
386 // What some outdated/incorrect ones have
387 || lilv_plugin_has_feature(plugin, state_uri);
388 lilv_node_free(state_uri);
389 lilv_node_free(state_iface_uri);
391 _features = (LV2_Feature**)calloc(12, sizeof(LV2_Feature*));
392 _features[0] = &_instance_access_feature;
393 _features[1] = &_data_access_feature;
394 _features[2] = &_make_path_feature;
395 _features[3] = _uri_map.uri_map_feature();
396 _features[4] = _uri_map.urid_map_feature();
397 _features[5] = _uri_map.urid_unmap_feature();
398 _features[6] = &_log_feature;
400 unsigned n_features = 7;
401 #ifdef HAVE_LV2_1_2_0
402 _features[n_features++] = &_def_state_feature;
405 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
406 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
409 _impl->queue_draw = (LV2_Inline_Display*)
410 malloc (sizeof(LV2_Inline_Display));
411 _impl->queue_draw->handle = this;
412 _impl->queue_draw->queue_draw = queue_draw;
414 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
415 _queue_draw_feature.data = _impl->queue_draw;
416 _features[n_features++] = &_queue_draw_feature;
419 #ifdef HAVE_LV2_1_2_0
420 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
421 static const int32_t _min_block_length = 1; // may happen during split-cycles
422 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
423 /* Consider updating max-block-size whenever the buffersize changes.
424 * It requires re-instantiating the plugin (which is a non-realtime operation),
425 * so it should be done lightly and only for plugins that require it.
427 * given that the block-size can change at any time (split-cycles) ardour currently
428 * does not support plugins that require bufz_fixedBlockLength.
430 LV2_Options_Option options[] = {
431 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
432 sizeof(int32_t), atom_Int, &_min_block_length },
433 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
434 sizeof(int32_t), atom_Int, &_max_block_length },
435 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
436 sizeof(int32_t), atom_Int, &_seq_size },
437 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
438 sizeof(int32_t), atom_Int, &_impl->block_length },
439 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
442 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
443 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
445 _options_feature.URI = LV2_OPTIONS__options;
446 _options_feature.data = _impl->options;
447 _features[n_features++] = &_options_feature;
450 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
451 sizeof(LV2_State_Make_Path));
452 make_path->handle = this;
453 make_path->path = &lv2_state_make_path;
454 _make_path_feature.data = make_path;
456 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
458 log->printf = &log_printf;
459 log->vprintf = &log_vprintf;
460 _log_feature.data = log;
462 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
463 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
464 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
465 sizeof(LV2_Worker_Schedule));
466 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
467 _worker = new Worker(this, buf_size);
468 schedule->handle = this;
469 schedule->schedule_work = work_schedule;
470 _work_schedule_feature.data = schedule;
471 _features[n_features++] = &_work_schedule_feature;
473 lilv_node_free(worker_schedule);
475 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
476 _impl->name = lilv_plugin_get_name(plugin);
477 _impl->author = lilv_plugin_get_author_name(plugin);
479 if (_impl->instance == 0) {
480 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
481 throw failed_constructor();
484 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
485 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
486 _data_access_feature.data = &_data_access_extension_data;
488 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
489 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
490 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
491 LV2_WORKER__interface);
493 lilv_node_free(worker_iface_uri);
496 #ifdef HAVE_LV2_1_2_0
497 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
498 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
499 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
500 LV2_OPTIONS__interface);
502 lilv_node_free(options_iface_uri);
506 _display_interface = (const LV2_Inline_Display_Interface*)
507 extension_data (LV2_INLINEDISPLAY__interface);
510 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
511 error << string_compose(
512 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
513 lilv_node_as_string(_impl->name)) << endmsg;
514 lilv_node_free(_impl->name);
515 lilv_node_free(_impl->author);
516 throw failed_constructor();
519 #ifdef HAVE_LV2_1_2_0
520 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
521 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
522 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
524 error << string_compose(
525 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
526 lilv_node_as_string(_impl->name)) << endmsg;
527 lilv_node_free(_impl->name);
528 lilv_node_free(_impl->author);
529 lilv_nodes_free(required_features);
530 throw failed_constructor();
532 lilv_nodes_free(required_features);
536 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
537 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
538 _no_sample_accurate_ctrl = true;
540 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
541 _can_write_automation = true;
543 lilv_nodes_free(optional_features);
546 #ifdef HAVE_LILV_0_16_0
547 // Load default state
548 LilvState* state = lilv_state_new_from_world(
549 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
550 if (state && _has_state_interface) {
551 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
553 lilv_state_free(state);
558 const uint32_t num_ports = this->num_ports();
559 for (uint32_t i = 0; i < num_ports; ++i) {
560 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
562 size_t minimumSize = 0;
564 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
565 flags |= PORT_OUTPUT;
566 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
569 error << string_compose(
570 "LV2: \"%1\" port %2 is neither input nor output",
571 lilv_node_as_string(_impl->name), i) << endmsg;
572 throw failed_constructor();
575 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
576 flags |= PORT_CONTROL;
577 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
579 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
581 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
582 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
583 LilvNodes* buffer_types = lilv_port_get_value(
584 _impl->plugin, port, _world.atom_bufferType);
585 LilvNodes* atom_supports = lilv_port_get_value(
586 _impl->plugin, port, _world.atom_supports);
588 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
589 flags |= PORT_SEQUENCE;
590 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
593 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
594 flags |= PORT_POSITION;
597 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
598 flags |= PORT_AUTOCTRL;
601 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
602 flags |= PORT_PATCHMSG;
603 if (flags & PORT_INPUT) {
604 _patch_port_in_index = i;
606 _patch_port_out_index = i;
610 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
611 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
612 if (min_size && lilv_node_is_int(min_size)) {
613 minimumSize = lilv_node_as_int(min_size);
615 lilv_nodes_free(min_size_v);
616 lilv_nodes_free(buffer_types);
617 lilv_nodes_free(atom_supports);
619 error << string_compose(
620 "LV2: \"%1\" port %2 has no known data type",
621 lilv_node_as_string(_impl->name), i) << endmsg;
622 throw failed_constructor();
626 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
627 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
628 flags |= PORT_CTRLED;
633 _port_flags.push_back(flags);
634 _port_minimumSize.push_back(minimumSize);
637 _control_data = new float[num_ports];
638 _shadow_data = new float[num_ports];
639 _defaults = new float[num_ports];
640 _ev_buffers = new LV2_Evbuf*[num_ports];
641 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
643 const bool latent = lilv_plugin_has_latency(plugin);
644 const uint32_t latency_index = (latent)
645 ? lilv_plugin_get_latency_port_index(plugin)
648 // Build an array of pointers to special parameter buffers
649 void*** params = new void**[num_ports];
650 for (uint32_t i = 0; i < num_ports; ++i) {
653 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
654 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
656 for (uint32_t i = 0; i < num_ports; ++i) {
657 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
658 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
660 // Store index in map so we can look up index by symbol
661 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
663 // Get range and default value if applicable
664 if (parameter_is_control(i)) {
666 lilv_port_get_range(plugin, port, &def, NULL, NULL);
667 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
668 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
669 _defaults[i] *= _session.frame_rate ();
673 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
675 if (latent && i == latency_index) {
676 _latency_control_port = &_control_data[i];
677 *_latency_control_port = 0;
680 if (parameter_is_input(i)) {
681 _shadow_data[i] = default_value(i);
683 *params[i] = (void*)&_shadow_data[i];
693 LilvUIs* uis = lilv_plugin_get_uis(plugin);
694 if (lilv_uis_size(uis) > 0) {
696 // Look for embeddable UI
697 LILV_FOREACH(uis, u, uis) {
698 const LilvUI* this_ui = lilv_uis_get(uis, u);
699 const LilvNode* this_ui_type = NULL;
700 if (lilv_ui_is_supported(this_ui,
704 // TODO: Multiple UI support
706 _impl->ui_type = this_ui_type;
711 // Look for Gtk native UI
712 LILV_FOREACH(uis, i, uis) {
713 const LilvUI* ui = lilv_uis_get(uis, i);
714 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
716 _impl->ui_type = _world.ui_GtkUI;
722 // If Gtk UI is not available, try to find external UI
724 LILV_FOREACH(uis, i, uis) {
725 const LilvUI* ui = lilv_uis_get(uis, i);
726 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
728 _impl->ui_type = _world.ui_external;
731 if (lilv_ui_is_a(ui, _world.ui_external)) {
733 _impl->ui_type = _world.ui_external;
739 load_supported_properties(_property_descriptors);
740 allocate_atom_event_buffers();
741 latency_compute_run();
745 LV2Plugin::set_block_size (pframes_t nframes)
747 #ifdef HAVE_LV2_1_2_0
748 if (_impl->opts_iface) {
749 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
750 _impl->block_length = nframes;
751 LV2_Options_Option block_size_option = {
752 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
753 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
755 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
762 LV2Plugin::requires_fixed_sized_buffers () const
764 /* This controls if Ardour will split the plugin's run()
765 * on automation events in order to pass sample-accurate automation
766 * via standard control-ports.
768 * When returning true Ardour will *not* sub-divide the process-cycle.
769 * Automation events that happen between cycle-start and cycle-end will be
770 * ignored (ctrl values are interpolated to cycle-start).
771 * NB. Atom Sequences are still sample accurate.
773 * Note: This does not guarantee a fixed block-size.
774 * e.g The process cycle may be split when looping, also
775 * the period-size may change any time: see set_block_size()
777 if (get_info()->n_inputs.n_midi() > 0) {
778 /* we don't yet implement midi buffer offsets (for split cycles).
779 * Also connect_and_run() also uses _session.transport_frame() directly
780 * (for BBT) which is not offset for plugin cycle split.
784 return _no_sample_accurate_ctrl;
787 LV2Plugin::~LV2Plugin ()
789 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
794 lilv_instance_free(_impl->instance);
795 lilv_state_free(_impl->state);
796 lilv_node_free(_impl->name);
797 lilv_node_free(_impl->author);
798 #ifdef HAVE_LV2_1_2_0
799 free(_impl->options);
802 free(_impl->queue_draw);
806 free(_make_path_feature.data);
807 free(_work_schedule_feature.data);
813 if (_atom_ev_buffers) {
814 LV2_Evbuf** b = _atom_ev_buffers;
819 free(_atom_ev_buffers);
822 delete [] _control_data;
823 delete [] _shadow_data;
825 delete [] _ev_buffers;
829 LV2Plugin::is_external_ui() const
834 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
838 LV2Plugin::is_external_kx() const
843 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
847 LV2Plugin::ui_is_resizable () const
849 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
850 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
851 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
852 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
854 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
855 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
857 lilv_nodes_free(nrs_matches);
858 lilv_nodes_free(fs_matches);
863 return !fs_matches && !nrs_matches;
868 LV2Plugin::has_inline_display () {
869 return _display_interface ? true : false;
872 Plugin::Display_Image_Surface*
873 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
874 if (_display_interface) {
875 /* Plugin::Display_Image_Surface is identical to
876 * LV2_Inline_Display_Image_Surface */
877 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
884 LV2Plugin::unique_id() const
886 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
890 LV2Plugin::uri() const
892 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
896 LV2Plugin::label() const
898 return lilv_node_as_string(_impl->name);
902 LV2Plugin::name() const
904 return lilv_node_as_string(_impl->name);
908 LV2Plugin::maker() const
910 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
914 LV2Plugin::num_ports() const
916 return lilv_plugin_get_num_ports(_impl->plugin);
920 LV2Plugin::parameter_count() const
922 return lilv_plugin_get_num_ports(_impl->plugin);
926 LV2Plugin::default_value(uint32_t port)
928 return _defaults[port];
932 LV2Plugin::port_symbol(uint32_t index) const
934 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
936 error << name() << ": Invalid port index " << index << endmsg;
939 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
940 return lilv_node_as_string(sym);
944 LV2Plugin::port_index (const char* symbol) const
946 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
947 if (i != _port_indices.end()) {
950 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
956 LV2Plugin::set_parameter(uint32_t which, float val)
958 DEBUG_TRACE(DEBUG::LV2, string_compose(
959 "%1 set parameter %2 to %3\n", name(), which, val));
961 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
962 if (get_parameter (which) == val) {
966 _shadow_data[which] = val;
968 warning << string_compose(
969 _("Illegal parameter number used with plugin \"%1\". "
970 "This is a bug in either %2 or the LV2 plugin <%3>"),
971 name(), PROGRAM_NAME, unique_id()) << endmsg;
974 Plugin::set_parameter(which, val);
978 LV2Plugin::get_parameter(uint32_t which) const
980 if (parameter_is_input(which)) {
981 return (float)_shadow_data[which];
983 return (float)_control_data[which];
989 LV2Plugin::get_docs() const
991 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
993 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
994 lilv_nodes_free(comments);
1002 LV2Plugin::get_parameter_docs(uint32_t which) const
1004 LilvNodes* comments = lilv_port_get_value(
1006 lilv_plugin_get_port_by_index(_impl->plugin, which),
1007 _world.rdfs_comment);
1010 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1011 lilv_nodes_free(comments);
1019 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1022 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1023 if (parameter_is_control(x)) {
1035 LV2Plugin::extension_data(const char* uri) const
1037 return lilv_instance_get_extension_data(_impl->instance, uri);
1041 LV2Plugin::c_plugin()
1043 return _impl->plugin;
1049 return (const void*)_impl->ui;
1053 LV2Plugin::c_ui_type()
1055 return (const void*)_impl->ui_type;
1058 /** Directory for all plugin state. */
1060 LV2Plugin::plugin_dir() const
1062 if (!_plugin_state_dir.empty ()){
1063 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1065 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1069 /** Directory for files created by the plugin (except during save). */
1071 LV2Plugin::scratch_dir() const
1073 return Glib::build_filename(plugin_dir(), "scratch");
1076 /** Directory for snapshots of files in the scratch directory. */
1078 LV2Plugin::file_dir() const
1080 return Glib::build_filename(plugin_dir(), "files");
1083 /** Directory to save state snapshot version @c num into. */
1085 LV2Plugin::state_dir(unsigned num) const
1087 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1090 /** Implementation of state:makePath for files created at instantiation time.
1091 * Note this is not used for files created at save time (Lilv deals with that).
1094 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1097 LV2Plugin* me = (LV2Plugin*)handle;
1098 if (me->_insert_id == PBD::ID("0")) {
1099 warning << string_compose(
1100 "File path \"%1\" requested but LV2 %2 has no insert ID",
1101 path, me->name()) << endmsg;
1102 return g_strdup(path);
1105 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1106 const std::string dirname = Glib::path_get_dirname(abs_path);
1107 g_mkdir_with_parents(dirname.c_str(), 0744);
1109 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1112 return g_strndup(abs_path.c_str(), abs_path.length());
1116 LV2Plugin::add_state(XMLNode* root) const
1118 assert(_insert_id != PBD::ID("0"));
1122 LocaleGuard lg(X_("C"));
1124 for (uint32_t i = 0; i < parameter_count(); ++i) {
1125 if (parameter_is_input(i) && parameter_is_control(i)) {
1126 child = new XMLNode("Port");
1127 child->add_property("symbol", port_symbol(i));
1128 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1129 child->add_property("value", string(buf));
1130 root->add_child_nocopy(*child);
1134 if (!_plugin_state_dir.empty()) {
1135 root->add_property("template-dir", _plugin_state_dir);
1138 if (_has_state_interface) {
1139 // Provisionally increment state version and create directory
1140 const std::string new_dir = state_dir(++_state_version);
1141 g_mkdir_with_parents(new_dir.c_str(), 0744);
1143 LilvState* state = lilv_state_new_from_instance(
1146 _uri_map.urid_map(),
1147 scratch_dir().c_str(),
1149 _session.externals_dir().c_str(),
1152 const_cast<LV2Plugin*>(this),
1156 if (!_plugin_state_dir.empty()
1158 || !lilv_state_equals(state, _impl->state)) {
1159 lilv_state_save(_world.world,
1160 _uri_map.urid_map(),
1161 _uri_map.urid_unmap(),
1167 if (_plugin_state_dir.empty()) {
1168 // normal session save
1169 lilv_state_free(_impl->state);
1170 _impl->state = state;
1172 // template save (dedicated state-dir)
1173 lilv_state_free(state);
1176 // State is identical, decrement version and nuke directory
1177 lilv_state_free(state);
1178 PBD::remove_directory(new_dir);
1182 root->add_property("state-dir", string_compose("state%1", _state_version));
1186 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1188 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1190 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1192 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1193 lilv_nodes_free(vs);
1200 LV2Plugin::find_presets()
1202 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1203 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1204 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1206 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1207 LILV_FOREACH(nodes, i, presets) {
1208 const LilvNode* preset = lilv_nodes_get(presets, i);
1209 lilv_world_load_resource(_world.world, preset);
1210 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1211 bool userpreset = true; // TODO
1213 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1214 Plugin::PresetRecord(
1215 lilv_node_as_string(preset),
1216 lilv_node_as_string(name),
1218 lilv_node_free(name);
1220 warning << string_compose(
1221 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1222 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1223 lilv_node_as_string(preset)) << endmsg;
1226 lilv_nodes_free(presets);
1228 lilv_node_free(rdfs_label);
1229 lilv_node_free(pset_Preset);
1230 lilv_node_free(lv2_appliesTo);
1234 set_port_value(const char* port_symbol,
1240 LV2Plugin* self = (LV2Plugin*)user_data;
1241 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1242 return; // TODO: Support non-float ports
1245 const uint32_t port_index = self->port_index(port_symbol);
1246 if (port_index != (uint32_t)-1) {
1247 self->set_parameter(port_index, *(const float*)value);
1252 LV2Plugin::load_preset(PresetRecord r)
1254 LilvWorld* world = _world.world;
1255 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1256 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1259 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1260 lilv_state_free(state);
1261 Plugin::load_preset(r);
1264 lilv_node_free(pset);
1269 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1274 LV2Plugin *plugin = (LV2Plugin *) user_data;
1276 uint32_t index = plugin->port_index(port_symbol);
1277 if (index != (uint32_t) -1) {
1278 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1280 *size = sizeof(float);
1281 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1282 value = &plugin->_shadow_data[index];
1294 LV2Plugin::do_save_preset(string name)
1296 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1297 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1298 const string base_name = legalize_for_uri(name);
1299 const string file_name = base_name + ".ttl";
1300 const string bundle = Glib::build_filename(
1301 Glib::get_home_dir(),
1302 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1304 #ifdef HAVE_LILV_0_21_3
1305 /* delete reference to old preset (if any) */
1306 const PresetRecord* r = preset_by_label(name);
1308 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1310 lilv_world_unload_resource (_world.world, pset);
1311 lilv_node_free(pset);
1316 LilvState* state = lilv_state_new_from_instance(
1319 _uri_map.urid_map(),
1320 scratch_dir().c_str(), // file_dir
1321 bundle.c_str(), // copy_dir
1322 bundle.c_str(), // link_dir
1323 bundle.c_str(), // save_dir
1324 lv2plugin_get_port_value, // get_value
1325 (void*)this, // user_data
1326 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1327 _features // features
1330 lilv_state_set_label(state, name.c_str());
1332 _world.world, // world
1333 _uri_map.urid_map(), // map
1334 _uri_map.urid_unmap(), // unmap
1336 NULL, // uri (NULL = use file URI)
1337 bundle.c_str(), // dir
1338 file_name.c_str() // filename
1341 lilv_state_free(state);
1343 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1344 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1345 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1346 #ifdef HAVE_LILV_0_21_3
1347 lilv_world_unload_resource(_world.world, node_preset);
1348 lilv_world_unload_bundle(_world.world, node_bundle);
1350 lilv_world_load_bundle(_world.world, node_bundle);
1351 lilv_world_load_resource(_world.world, node_preset);
1352 lilv_node_free(node_bundle);
1353 lilv_node_free(node_preset);
1354 lilv_node_free(plug_name);
1359 LV2Plugin::do_remove_preset(string name)
1361 #ifdef HAVE_LILV_0_21_3
1362 /* Look up preset record by label (FIXME: ick, label as ID) */
1363 const PresetRecord* r = preset_by_label(name);
1368 /* Load a LilvState for the preset. */
1369 LilvWorld* world = _world.world;
1370 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1371 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1373 lilv_node_free(pset);
1377 /* Unload preset from world. */
1378 lilv_world_unload_resource(world, pset);
1380 /* Delete it from the file system. This will remove the preset file and the entry
1381 from the manifest. If this results in an empty manifest (i.e. the
1382 preset is the only thing in the bundle), then the bundle is removed. */
1383 lilv_state_delete(world, state);
1385 lilv_state_free(state);
1386 lilv_node_free(pset);
1388 /* Without lilv_state_delete(), we could delete the preset file, but this
1389 would leave a broken bundle/manifest around, so the preset would still
1390 be visible, but broken. Naively deleting a bundle is too dangerous, so
1391 we simply do not support preset deletion with older Lilv */
1395 LV2Plugin::has_editor() const
1397 return _impl->ui != NULL;
1401 LV2Plugin::has_message_output() const
1403 for (uint32_t i = 0; i < num_ports(); ++i) {
1404 if ((_port_flags[i] & PORT_SEQUENCE) &&
1405 (_port_flags[i] & PORT_OUTPUT)) {
1413 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1417 const uint8_t* body)
1419 const uint32_t buf_size = sizeof(UIMessage) + size;
1420 vector<uint8_t> buf(buf_size);
1422 UIMessage* msg = (UIMessage*)&buf[0];
1424 msg->protocol = protocol;
1426 memcpy(msg + 1, body, size);
1428 return (dest->write(&buf[0], buf_size) == buf_size);
1432 LV2Plugin::write_from_ui(uint32_t index,
1435 const uint8_t* body)
1438 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1439 /* buffer data communication from plugin UI to plugin instance.
1440 * this buffer needs to potentially hold
1441 * (port's minimumSize) * (audio-periods) / (UI-periods)
1444 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1445 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1446 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1448 * it is NOT safe to overflow (msg.size will be misinterpreted)
1450 uint32_t bufsiz = 32768;
1451 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1452 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1454 rbs = max((size_t) bufsiz * 8, rbs);
1455 _from_ui = new RingBuffer<uint8_t>(rbs);
1458 if (!write_to(_from_ui, index, protocol, size, body)) {
1459 error << "Error writing from UI to plugin" << endmsg;
1466 LV2Plugin::write_to_ui(uint32_t index,
1469 const uint8_t* body)
1471 if (!write_to(_to_ui, index, protocol, size, body)) {
1472 error << "Error writing from plugin to UI" << endmsg;
1479 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1481 switch (value.type()) {
1482 case Variant::NOTHING:
1484 case Variant::BEATS:
1485 // No atom type for this, just forge a double
1486 lv2_atom_forge_double(forge, value.get_beats().to_double());
1489 lv2_atom_forge_bool(forge, value.get_bool());
1491 case Variant::DOUBLE:
1492 lv2_atom_forge_double(forge, value.get_double());
1494 case Variant::FLOAT:
1495 lv2_atom_forge_float(forge, value.get_float());
1498 lv2_atom_forge_int(forge, value.get_int());
1501 lv2_atom_forge_long(forge, value.get_long());
1504 lv2_atom_forge_path(
1505 forge, value.get_path().c_str(), value.get_path().size());
1507 case Variant::STRING:
1508 lv2_atom_forge_string(
1509 forge, value.get_string().c_str(), value.get_string().size());
1513 forge, value.get_uri().c_str(), value.get_uri().size());
1518 /** Get a variant type from a URI, return false iff no match found. */
1520 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1522 if (uri == LV2_ATOM__Bool) {
1523 type = Variant::BOOL;
1524 } else if (uri == LV2_ATOM__Double) {
1525 type = Variant::DOUBLE;
1526 } else if (uri == LV2_ATOM__Float) {
1527 type = Variant::FLOAT;
1528 } else if (uri == LV2_ATOM__Int) {
1529 type = Variant::INT;
1530 } else if (uri == LV2_ATOM__Long) {
1531 type = Variant::LONG;
1532 } else if (uri == LV2_ATOM__Path) {
1533 type = Variant::PATH;
1534 } else if (uri == LV2_ATOM__String) {
1535 type = Variant::STRING;
1536 } else if (uri == LV2_ATOM__URI) {
1537 type = Variant::URI;
1545 LV2Plugin::set_property(uint32_t key, const Variant& value)
1547 if (_patch_port_in_index == (uint32_t)-1) {
1548 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1550 } else if (value.type() == Variant::NOTHING) {
1551 error << "LV2: set_property called with void value" << endmsg;
1555 // Set up forge to write to temporary buffer on the stack
1556 LV2_Atom_Forge* forge = &_impl->ui_forge;
1557 LV2_Atom_Forge_Frame frame;
1558 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1560 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1562 // Serialize patch:Set message to set property
1563 #ifdef HAVE_LV2_1_10_0
1564 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1565 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1566 lv2_atom_forge_urid(forge, key);
1567 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1569 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1570 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1571 lv2_atom_forge_urid(forge, key);
1572 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1575 forge_variant(forge, value);
1577 // Write message to UI=>Plugin ring
1578 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1579 write_from_ui(_patch_port_in_index,
1580 _uri_map.urids.atom_eventTransfer,
1581 lv2_atom_total_size(atom),
1582 (const uint8_t*)atom);
1585 const ParameterDescriptor&
1586 LV2Plugin::get_property_descriptor(uint32_t id) const
1588 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1589 if (p != _property_descriptors.end()) {
1592 return Plugin::get_property_descriptor(id);
1596 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1598 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1599 desc.unit = ParameterDescriptor::MIDI_NOTE;
1600 } else if (lilv_nodes_contains(units, _world.units_db)) {
1601 desc.unit = ParameterDescriptor::DB;
1602 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1603 desc.unit = ParameterDescriptor::HZ;
1605 if (lilv_nodes_size(units) > 0) {
1606 const LilvNode* unit = lilv_nodes_get_first(units);
1607 LilvNode* render = get_value(lworld, unit, _world.units_render);
1609 desc.print_fmt = lilv_node_as_string(render);
1610 lilv_node_free(render);
1616 load_parameter_descriptor(LV2World& world,
1617 ParameterDescriptor& desc,
1618 Variant::Type datatype,
1619 const LilvNode* subject)
1621 LilvWorld* lworld = _world.world;
1622 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1623 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1624 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1625 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1626 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1628 desc.label = lilv_node_as_string(label);
1630 if (def && lilv_node_is_float(def)) {
1631 desc.normal = lilv_node_as_float(def);
1633 if (minimum && lilv_node_is_float(minimum)) {
1634 desc.lower = lilv_node_as_float(minimum);
1636 if (maximum && lilv_node_is_float(maximum)) {
1637 desc.upper = lilv_node_as_float(maximum);
1639 load_parameter_descriptor_units(lworld, desc, units);
1640 desc.datatype = datatype;
1641 desc.toggled |= datatype == Variant::BOOL;
1642 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1643 desc.update_steps();
1645 lilv_nodes_free(units);
1646 lilv_node_free(label);
1647 lilv_node_free(def);
1648 lilv_node_free(minimum);
1649 lilv_node_free(maximum);
1653 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1655 LilvWorld* lworld = _world.world;
1656 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1657 LilvNodes* properties = lilv_world_find_nodes(
1658 lworld, subject, _world.patch_writable, NULL);
1659 LILV_FOREACH(nodes, p, properties) {
1660 // Get label and range
1661 const LilvNode* prop = lilv_nodes_get(properties, p);
1662 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1664 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1665 lilv_node_as_uri(prop)) << endmsg;
1669 // Convert range to variant type (TODO: support for multiple range types)
1670 Variant::Type datatype;
1671 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1672 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1673 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1677 // Add description to result
1678 ParameterDescriptor desc;
1679 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1680 desc.datatype = datatype;
1681 load_parameter_descriptor(_world, desc, datatype, prop);
1682 descs.insert(std::make_pair(desc.key, desc));
1684 lilv_node_free(range);
1686 lilv_nodes_free(properties);
1690 LV2Plugin::announce_property_values()
1692 if (_patch_port_in_index == (uint32_t)-1) {
1696 // Set up forge to write to temporary buffer on the stack
1697 LV2_Atom_Forge* forge = &_impl->ui_forge;
1698 LV2_Atom_Forge_Frame frame;
1699 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1701 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1703 // Serialize patch:Get message with no subject (implicitly plugin instance)
1704 #ifdef HAVE_LV2_1_10_0
1705 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1707 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1710 // Write message to UI=>Plugin ring
1711 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1712 write_from_ui(_patch_port_in_index,
1713 _uri_map.urids.atom_eventTransfer,
1714 lv2_atom_total_size(atom),
1715 (const uint8_t*)atom);
1719 LV2Plugin::enable_ui_emission()
1722 /* see note in LV2Plugin::write_from_ui() */
1723 uint32_t bufsiz = 32768;
1724 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1725 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1727 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1728 rbs = max((size_t) bufsiz * 8, rbs);
1729 _to_ui = new RingBuffer<uint8_t>(rbs);
1734 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1740 uint32_t read_space = _to_ui->read_space();
1741 while (read_space > sizeof(UIMessage)) {
1743 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1744 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1747 vector<uint8_t> body(msg.size);
1748 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1749 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1753 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1755 read_space -= sizeof(msg) + msg.size;
1760 LV2Plugin::work(uint32_t size, const void* data)
1762 return _impl->work_iface->work(
1763 _impl->instance->lv2_handle, work_respond, this, size, data);
1767 LV2Plugin::work_response(uint32_t size, const void* data)
1769 return _impl->work_iface->work_response(
1770 _impl->instance->lv2_handle, size, data);
1774 LV2Plugin::set_insert_id(PBD::ID id)
1776 if (_insert_id == "0") {
1778 } else if (_insert_id != id) {
1779 lilv_state_free(_impl->state);
1780 _impl->state = NULL;
1786 LV2Plugin::set_state_dir (const std::string& d)
1788 _plugin_state_dir = d;
1792 LV2Plugin::set_state(const XMLNode& node, int version)
1795 const XMLProperty* prop;
1796 XMLNodeConstIterator iter;
1801 LocaleGuard lg(X_("C"));
1803 if (node.name() != state_node_name()) {
1804 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1808 #ifndef NO_PLUGIN_STATE
1810 if (version < 3000) {
1811 nodes = node.children("port");
1813 nodes = node.children("Port");
1816 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1820 if ((prop = child->property("symbol")) != 0) {
1821 sym = prop->value().c_str();
1823 warning << _("LV2: port has no symbol, ignored") << endmsg;
1827 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1829 if (i != _port_indices.end()) {
1830 port_id = i->second;
1832 warning << _("LV2: port has unknown index, ignored") << endmsg;
1836 if ((prop = child->property("value")) != 0) {
1837 value = prop->value().c_str();
1839 warning << _("LV2: port has no value, ignored") << endmsg;
1843 set_parameter(port_id, atof(value));
1846 if ((prop = node.property("template-dir")) != 0) {
1847 set_state_dir (prop->value ());
1851 if ((prop = node.property("state-dir")) != 0) {
1852 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1853 error << string_compose(
1854 "LV2: failed to parse state version from \"%1\"",
1855 prop->value()) << endmsg;
1858 std::string state_file = Glib::build_filename(
1860 Glib::build_filename(prop->value(), "state.ttl"));
1862 LilvState* state = lilv_state_new_from_file(
1863 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1865 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1866 lilv_state_free(_impl->state);
1867 _impl->state = state;
1870 if (!_plugin_state_dir.empty ()) {
1871 // force save with session, next time (increment counter)
1872 lilv_state_free (_impl->state);
1873 _impl->state = NULL;
1877 latency_compute_run();
1880 return Plugin::set_state(node, version);
1884 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1886 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1888 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1893 LilvNodes* portunits;
1894 LilvNode *def, *min, *max;
1895 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1896 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1898 // TODO: Once we can rely on lilv 0.18.0 being present,
1899 // load_parameter_descriptor() can be used for ports as well
1900 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1901 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1902 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1903 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1904 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1905 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1906 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1907 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1908 load_parameter_descriptor_units(_world.world, desc, portunits);
1910 if (desc.sr_dependent) {
1911 desc.lower *= _session.frame_rate ();
1912 desc.upper *= _session.frame_rate ();
1915 desc.min_unbound = false; // TODO: LV2 extension required
1916 desc.max_unbound = false; // TODO: LV2 extension required
1918 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1919 desc.scale_points = get_scale_points(which);
1921 desc.update_steps();
1923 lilv_node_free(def);
1924 lilv_node_free(min);
1925 lilv_node_free(max);
1926 lilv_nodes_free(portunits);
1931 Plugin::IOPortDescription
1932 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id)
1934 PortFlags match = 0;
1936 case DataType::AUDIO:
1939 case DataType::MIDI:
1940 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
1943 return Plugin::IOPortDescription ("?");
1947 match |= PORT_INPUT;
1949 match |= PORT_OUTPUT;
1953 uint32_t idx = UINT32_MAX;
1955 uint32_t const num_ports = parameter_count();
1956 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1957 PortFlags flags = _port_flags[port_index];
1958 if ((flags & match) == match) {
1965 if (idx == UINT32_MAX) {
1966 return Plugin::IOPortDescription ("?");
1969 LilvNode* name = lilv_port_get_name(_impl->plugin,
1970 lilv_plugin_get_port_by_index(_impl->plugin, idx));
1971 Plugin::IOPortDescription iod (lilv_node_as_string (name));
1972 lilv_node_free(name);
1974 if (lilv_port_has_property(_impl->plugin,
1975 lilv_plugin_get_port_by_index(_impl->plugin, idx), _world.lv2_isSideChain)) {
1976 iod.is_sidechain = true;
1982 LV2Plugin::describe_parameter(Evoral::Parameter which)
1984 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1986 if (lilv_port_has_property(_impl->plugin,
1987 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1988 return X_("hidden");
1991 if (lilv_port_has_property(_impl->plugin,
1992 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
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_reportsLatency)) {
1998 return X_("latency");
2001 LilvNode* name = lilv_port_get_name(_impl->plugin,
2002 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2003 string ret(lilv_node_as_string(name));
2004 lilv_node_free(name);
2012 LV2Plugin::signal_latency() const
2014 if (_latency_control_port) {
2015 return (framecnt_t)floor(*_latency_control_port);
2021 set<Evoral::Parameter>
2022 LV2Plugin::automatable() const
2024 set<Evoral::Parameter> ret;
2026 for (uint32_t i = 0; i < parameter_count(); ++i) {
2027 if (parameter_is_input(i) && parameter_is_control(i)) {
2028 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2032 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2033 p != _property_descriptors.end();
2035 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2041 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2043 if ((_port_flags[i] & PORT_CTRLED)) {
2044 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2048 LV2Plugin::AutomationCtrlPtr
2049 LV2Plugin::get_automation_control (uint32_t i)
2051 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2052 return AutomationCtrlPtr ();
2054 return _ctrl_map[i];
2058 LV2Plugin::activate()
2060 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2062 if (!_was_activated) {
2063 lilv_instance_activate(_impl->instance);
2064 _was_activated = true;
2069 LV2Plugin::deactivate()
2071 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2073 if (_was_activated) {
2074 lilv_instance_deactivate(_impl->instance);
2075 _was_activated = false;
2080 LV2Plugin::cleanup()
2082 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2085 lilv_instance_free(_impl->instance);
2086 _impl->instance = NULL;
2090 LV2Plugin::allocate_atom_event_buffers()
2092 /* reserve local scratch buffers for ATOM event-queues */
2093 const LilvPlugin* p = _impl->plugin;
2095 /* count non-MIDI atom event-ports
2096 * TODO: nicely ask drobilla to make a lilv_ call for that
2098 int count_atom_out = 0;
2099 int count_atom_in = 0;
2100 int minimumSize = 32768; // TODO use a per-port minimum-size
2101 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2102 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2103 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2104 LilvNodes* buffer_types = lilv_port_get_value(
2105 p, port, _world.atom_bufferType);
2106 LilvNodes* atom_supports = lilv_port_get_value(
2107 p, port, _world.atom_supports);
2109 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
2110 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
2111 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2114 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2117 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2118 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2119 if (min_size && lilv_node_is_int(min_size)) {
2120 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2122 lilv_nodes_free(min_size_v);
2124 lilv_nodes_free(buffer_types);
2125 lilv_nodes_free(atom_supports);
2129 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2130 name(), count_atom_in, count_atom_out));
2132 const int total_atom_buffers = (count_atom_in + count_atom_out);
2133 if (_atom_ev_buffers || total_atom_buffers == 0) {
2137 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
2138 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2139 for (int i = 0; i < total_atom_buffers; ++i ) {
2140 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2141 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2143 _atom_ev_buffers[total_atom_buffers] = 0;
2147 /** Write an ardour position/time/tempo/meter as an LV2 event.
2148 * @return true on success.
2151 write_position(LV2_Atom_Forge* forge,
2153 const TempoMetric& t,
2154 Timecode::BBT_Time& bbt,
2156 framepos_t position,
2159 const URIMap::URIDs& urids = URIMap::instance().urids;
2161 uint8_t pos_buf[256];
2162 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2163 LV2_Atom_Forge_Frame frame;
2164 #ifdef HAVE_LV2_1_10_0
2165 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2166 lv2_atom_forge_key(forge, urids.time_frame);
2167 lv2_atom_forge_long(forge, position);
2168 lv2_atom_forge_key(forge, urids.time_speed);
2169 lv2_atom_forge_float(forge, speed);
2170 lv2_atom_forge_key(forge, urids.time_barBeat);
2171 lv2_atom_forge_float(forge, bbt.beats - 1 +
2172 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2173 lv2_atom_forge_key(forge, urids.time_bar);
2174 lv2_atom_forge_long(forge, bbt.bars - 1);
2175 lv2_atom_forge_key(forge, urids.time_beatUnit);
2176 lv2_atom_forge_int(forge, t.meter().note_divisor());
2177 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2178 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2179 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2180 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2182 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2183 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2184 lv2_atom_forge_long(forge, position);
2185 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2186 lv2_atom_forge_float(forge, speed);
2187 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2188 lv2_atom_forge_float(forge, bbt.beats - 1 +
2189 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2190 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2191 lv2_atom_forge_long(forge, bbt.bars - 1);
2192 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2193 lv2_atom_forge_int(forge, t.meter().note_divisor());
2194 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2195 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2196 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2197 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2200 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2201 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2202 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2203 (const uint8_t*)(atom + 1));
2207 LV2Plugin::connect_and_run(BufferSet& bufs,
2208 ChanMapping in_map, ChanMapping out_map,
2209 pframes_t nframes, framecnt_t offset)
2211 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2212 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2214 cycles_t then = get_cycles();
2216 TempoMap& tmap = _session.tempo_map();
2217 Metrics::const_iterator metric_i = tmap.metrics_end();
2218 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
2220 if (_freewheel_control_port) {
2221 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2224 if (_bpm_control_port) {
2225 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2229 if (_can_write_automation && _session.transport_frame() != _next_cycle_start) {
2230 // add guard-points after locating
2231 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2232 i->second->guard = true;
2237 ChanCount bufs_count;
2238 bufs_count.set(DataType::AUDIO, 1);
2239 bufs_count.set(DataType::MIDI, 1);
2240 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2241 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2242 uint32_t const num_ports = parameter_count();
2243 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2245 uint32_t audio_in_index = 0;
2246 uint32_t audio_out_index = 0;
2247 uint32_t midi_in_index = 0;
2248 uint32_t midi_out_index = 0;
2249 uint32_t atom_port_index = 0;
2250 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2252 uint32_t index = nil_index;
2253 PortFlags flags = _port_flags[port_index];
2255 if (flags & PORT_AUDIO) {
2256 if (flags & PORT_INPUT) {
2257 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2259 ? bufs.get_audio(index).data(offset)
2260 : silent_bufs.get_audio(0).data(offset);
2262 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2264 ? bufs.get_audio(index).data(offset)
2265 : scratch_bufs.get_audio(0).data(offset);
2267 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2268 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2269 be necessary, but the mapping is illegal in some cases. Ideally
2270 that should be fixed, but this is easier...
2272 if (flags & PORT_MIDI) {
2273 if (flags & PORT_INPUT) {
2274 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2276 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2278 if (valid && bufs.count().n_midi() > index) {
2279 /* Note, ensure_lv2_bufsize() is not RT safe!
2280 * However free()/alloc() is only called if a
2281 * plugin requires a rsz:minimumSize buffersize
2282 * and the existing buffer if smaller.
2284 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2285 _ev_buffers[port_index] = bufs.get_lv2_midi(
2286 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2288 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2289 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2290 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2294 if (valid && (flags & PORT_INPUT)) {
2295 Timecode::BBT_Time bbt;
2296 if ((flags & PORT_POSITION)) {
2297 if (_session.transport_frame() != _next_cycle_start ||
2298 _session.transport_speed() != _next_cycle_speed) {
2299 // Transport has changed, write position at cycle start
2300 tmap.bbt_time(_session.transport_frame(), bbt);
2301 write_position(&_impl->forge, _ev_buffers[port_index],
2302 tmetric, bbt, _session.transport_speed(),
2303 _session.transport_frame(), 0);
2307 // Get MIDI iterator range (empty range if no MIDI)
2308 MidiBuffer::iterator m = (index != nil_index)
2309 ? bufs.get_midi(index).begin()
2310 : silent_bufs.get_midi(0).end();
2311 MidiBuffer::iterator m_end = (index != nil_index)
2312 ? bufs.get_midi(index).end()
2315 // Now merge MIDI and any transport events into the buffer
2316 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2317 const framepos_t tend = _session.transport_frame() + nframes;
2319 while (m != m_end || (metric_i != tmap.metrics_end() &&
2320 (*metric_i)->frame() < tend)) {
2321 MetricSection* metric = (metric_i != tmap.metrics_end())
2323 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2324 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2325 if (ev.time() < nframes) {
2326 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2327 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2331 tmetric.set_metric(metric);
2332 bbt = metric->start();
2333 write_position(&_impl->forge, _ev_buffers[port_index],
2334 tmetric, bbt, _session.transport_speed(),
2336 metric->frame() - _session.transport_frame());
2340 } else if (!valid) {
2341 // Nothing we understand or care about, connect to scratch
2342 // see note for midi-buffer size above
2343 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2344 0, _port_minimumSize[port_index]);
2345 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2346 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2349 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2351 continue; // Control port, leave buffer alone
2353 lilv_instance_connect_port(_impl->instance, port_index, buf);
2356 // Read messages from UI and push into appropriate buffers
2358 uint32_t read_space = _from_ui->read_space();
2359 while (read_space > sizeof(UIMessage)) {
2361 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2362 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2365 vector<uint8_t> body(msg.size);
2366 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2367 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2370 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2371 LV2_Evbuf* buf = _ev_buffers[msg.index];
2372 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2373 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2374 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2375 (const uint8_t*)(atom + 1))) {
2376 error << "Failed to write data to LV2 event buffer\n";
2379 error << "Received unknown message type from UI" << endmsg;
2381 read_space -= sizeof(UIMessage) + msg.size;
2388 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2389 PortFlags flags = _port_flags[port_index];
2392 /* TODO ask drobilla about comment
2393 * "Make Ardour event buffers generic so plugins can communicate"
2394 * in libs/ardour/buffer_set.cc:310
2396 * ideally the user could choose which of the following two modes
2397 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2399 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2400 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2401 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2402 * for quite a while at least ;)
2404 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2405 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2406 const uint32_t buf_index = out_map.get(
2407 DataType::MIDI, midi_out_index++, &valid);
2409 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2412 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2413 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2414 const uint32_t buf_index = out_map.get(
2415 DataType::MIDI, midi_out_index++, &valid);
2417 bufs.flush_lv2_midi(true, buf_index);
2421 // Write messages to UI
2422 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2423 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2424 LV2_Evbuf* buf = _ev_buffers[port_index];
2425 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2426 lv2_evbuf_is_valid(i);
2427 i = lv2_evbuf_next(i)) {
2428 uint32_t frames, subframes, type, size;
2430 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2433 // Intercept Automation Write Events
2434 if ((flags & PORT_AUTOCTRL)) {
2435 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2436 if (atom->type == _uri_map.urids.atom_Blank ||
2437 atom->type == _uri_map.urids.atom_Object) {
2438 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2439 if (obj->body.otype == _uri_map.urids.auto_event) {
2440 // only if transport_rolling ??
2441 const LV2_Atom* parameter = NULL;
2442 const LV2_Atom* value = NULL;
2443 lv2_atom_object_get(obj,
2444 _uri_map.urids.auto_parameter, ¶meter,
2445 _uri_map.urids.auto_value, &value,
2447 if (parameter && value) {
2448 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2449 const float v = ((const LV2_Atom_Float*)value)->body;
2450 // -> add automation event..
2451 AutomationCtrlPtr c = get_automation_control (p);
2452 if (c && c->ac->automation_state() == Touch) {
2455 c->ac->list()->add (_session.transport_frame() + frames, v, true, true);
2457 c->ac->set_double (v, _session.transport_frame() + frames, true);
2462 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2463 // TODO optional arguments, for now we assume the plugin
2464 // writes automation for its own inputs
2465 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2466 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2467 i->second->ac->set_automation_state (Touch);
2470 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2471 // set [touched] parameters to "play" ??
2473 else if (obj->body.otype == _uri_map.urids.auto_start) {
2474 const LV2_Atom* parameter = NULL;
2475 lv2_atom_object_get(obj,
2476 _uri_map.urids.auto_parameter, ¶meter,
2479 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2480 AutomationCtrlPtr c = get_automation_control (p);
2482 c->ac->start_touch (_session.transport_frame());
2487 else if (obj->body.otype == _uri_map.urids.auto_end) {
2488 const LV2_Atom* parameter = NULL;
2489 lv2_atom_object_get(obj,
2490 _uri_map.urids.auto_parameter, ¶meter,
2493 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2494 AutomationCtrlPtr c = get_automation_control (p);
2496 c->ac->stop_touch (true, _session.transport_frame());
2504 // Intercept patch change messages to emit PropertyChanged signal
2505 if ((flags & PORT_PATCHMSG)) {
2506 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2507 if (atom->type == _uri_map.urids.atom_Blank ||
2508 atom->type == _uri_map.urids.atom_Object) {
2509 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2510 if (obj->body.otype == _uri_map.urids.patch_Set) {
2511 const LV2_Atom* property = NULL;
2512 const LV2_Atom* value = NULL;
2513 lv2_atom_object_get(obj,
2514 _uri_map.urids.patch_property, &property,
2515 _uri_map.urids.patch_value, &value,
2518 if (property && value &&
2519 property->type == _uri_map.urids.atom_URID &&
2520 value->type == _uri_map.urids.atom_Path) {
2521 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2522 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2524 // Emit PropertyChanged signal for UI
2525 // TODO: This should emit the control's Changed signal
2526 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2528 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2534 if (!_to_ui) continue;
2535 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2536 size + sizeof(LV2_Atom),
2537 data - sizeof(LV2_Atom));
2542 cycles_t now = get_cycles();
2543 set_cycles((uint32_t)(now - then));
2545 // Update expected transport information for next cycle so we can detect changes
2546 _next_cycle_speed = _session.transport_speed();
2547 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2553 LV2Plugin::parameter_is_control(uint32_t param) const
2555 assert(param < _port_flags.size());
2556 return _port_flags[param] & PORT_CONTROL;
2560 LV2Plugin::parameter_is_audio(uint32_t param) const
2562 assert(param < _port_flags.size());
2563 return _port_flags[param] & PORT_AUDIO;
2567 LV2Plugin::parameter_is_event(uint32_t param) const
2569 assert(param < _port_flags.size());
2570 return _port_flags[param] & PORT_EVENT;
2574 LV2Plugin::parameter_is_output(uint32_t param) const
2576 assert(param < _port_flags.size());
2577 return _port_flags[param] & PORT_OUTPUT;
2581 LV2Plugin::parameter_is_input(uint32_t param) const
2583 assert(param < _port_flags.size());
2584 return _port_flags[param] & PORT_INPUT;
2588 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2591 if (param < parameter_count()) {
2592 snprintf(buf, len, "%.3f", get_parameter(param));
2599 boost::shared_ptr<ScalePoints>
2600 LV2Plugin::get_scale_points(uint32_t port_index) const
2602 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2603 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2605 boost::shared_ptr<ScalePoints> ret;
2610 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2612 LILV_FOREACH(scale_points, i, points) {
2613 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2614 const LilvNode* label = lilv_scale_point_get_label(p);
2615 const LilvNode* value = lilv_scale_point_get_value(p);
2616 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2617 ret->insert(make_pair(lilv_node_as_string(label),
2618 lilv_node_as_float(value)));
2622 lilv_scale_points_free(points);
2627 LV2Plugin::run(pframes_t nframes)
2629 uint32_t const N = parameter_count();
2630 for (uint32_t i = 0; i < N; ++i) {
2631 if (parameter_is_control(i) && parameter_is_input(i)) {
2632 _control_data[i] = _shadow_data[i];
2636 lilv_instance_run(_impl->instance, nframes);
2638 if (_impl->work_iface) {
2639 _worker->emit_responses();
2640 if (_impl->work_iface->end_run) {
2641 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2647 LV2Plugin::latency_compute_run()
2649 if (!_latency_control_port) {
2653 // Run the plugin so that it can set its latency parameter
2655 bool was_activated = _was_activated;
2658 uint32_t port_index = 0;
2659 uint32_t in_index = 0;
2660 uint32_t out_index = 0;
2662 // this is done in the main thread. non realtime.
2663 const framecnt_t bufsize = _engine.samples_per_cycle();
2664 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2666 memset(buffer, 0, sizeof(float) * bufsize);
2668 // FIXME: Ensure plugins can handle in-place processing
2672 while (port_index < parameter_count()) {
2673 if (parameter_is_audio(port_index)) {
2674 if (parameter_is_input(port_index)) {
2675 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2677 } else if (parameter_is_output(port_index)) {
2678 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2687 if (was_activated) {
2694 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2696 const LilvPort* port = NULL;
2697 LilvNode* designation = lilv_new_uri(_world.world, uri);
2698 port = lilv_plugin_get_port_by_designation(
2699 plugin, _world.lv2_InputPort, designation);
2700 lilv_node_free(designation);
2702 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2707 static bool lv2_filter (const string& str, void* /*arg*/)
2709 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2711 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2715 LV2World::LV2World()
2716 : world(lilv_world_new())
2717 , _bundle_checked(false)
2719 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2720 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2721 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2722 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2723 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2724 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2725 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2726 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2727 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2728 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2729 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2730 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2731 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2732 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2733 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
2734 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2735 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2736 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2737 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2738 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2739 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2740 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2741 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2742 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2743 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2744 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2745 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2746 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2747 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2748 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2749 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2750 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2751 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2752 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2753 units_render = lilv_new_uri(world, LV2_UNITS__render);
2754 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2755 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2756 units_db = lilv_new_uri(world, LV2_UNITS__db);
2757 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2758 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2760 lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2761 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
2762 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
2763 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
2765 #ifdef HAVE_LV2_1_2_0
2766 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2767 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2768 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2773 LV2World::~LV2World()
2778 #ifdef HAVE_LV2_1_2_0
2779 lilv_node_free(bufz_nominalBlockLength);
2780 lilv_node_free(bufz_fixedBlockLength);
2781 lilv_node_free(bufz_powerOf2BlockLength);
2784 lilv_node_free(lv2_noSampleAccurateCtrl);
2785 lilv_node_free(auto_can_write_automatation);
2786 lilv_node_free(auto_automation_control);
2787 lilv_node_free(auto_automation_controlled);
2789 lilv_node_free(patch_Message);
2790 lilv_node_free(patch_writable);
2791 lilv_node_free(units_hz);
2792 lilv_node_free(units_midiNote);
2793 lilv_node_free(units_db);
2794 lilv_node_free(units_unit);
2795 lilv_node_free(units_render);
2796 lilv_node_free(ui_externalkx);
2797 lilv_node_free(ui_external);
2798 lilv_node_free(ui_GtkUI);
2799 lilv_node_free(time_Position);
2800 lilv_node_free(rsz_minimumSize);
2801 lilv_node_free(rdfs_comment);
2802 lilv_node_free(rdfs_label);
2803 lilv_node_free(rdfs_range);
2804 lilv_node_free(midi_MidiEvent);
2805 lilv_node_free(lv2_enumeration);
2806 lilv_node_free(lv2_freewheeling);
2807 lilv_node_free(lv2_toggled);
2808 lilv_node_free(lv2_sampleRate);
2809 lilv_node_free(lv2_reportsLatency);
2810 lilv_node_free(lv2_integer);
2811 lilv_node_free(lv2_isSideChain);
2812 lilv_node_free(lv2_inPlaceBroken);
2813 lilv_node_free(lv2_OutputPort);
2814 lilv_node_free(lv2_InputPort);
2815 lilv_node_free(lv2_ControlPort);
2816 lilv_node_free(lv2_AudioPort);
2817 lilv_node_free(ext_notOnGUI);
2818 lilv_node_free(ext_logarithmic);
2819 lilv_node_free(ev_EventPort);
2820 lilv_node_free(atom_supports);
2821 lilv_node_free(atom_eventTransfer);
2822 lilv_node_free(atom_bufferType);
2823 lilv_node_free(atom_Sequence);
2824 lilv_node_free(atom_Chunk);
2825 lilv_node_free(atom_AtomPort);
2826 lilv_world_free(world);
2831 LV2World::load_bundled_plugins(bool verbose)
2833 if (!_bundle_checked) {
2835 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2838 vector<string> plugin_objects;
2839 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2840 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2841 #ifdef PLATFORM_WINDOWS
2842 string uri = "file:///" + *x + "/";
2844 string uri = "file://" + *x + "/";
2846 LilvNode *node = lilv_new_uri(world, uri.c_str());
2847 lilv_world_load_bundle(world, node);
2848 lilv_node_free(node);
2851 lilv_world_load_all(world);
2852 _bundle_checked = true;
2856 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2859 _plugin_uri = strdup(plugin_uri);
2862 LV2PluginInfo::~LV2PluginInfo()
2869 LV2PluginInfo::load(Session& session)
2873 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2874 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2875 if (!uri) { throw failed_constructor(); }
2876 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2877 if (!lp) { throw failed_constructor(); }
2878 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2879 lilv_node_free(uri);
2880 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2882 } catch (failed_constructor& err) {
2883 return PluginPtr((Plugin*)0);
2889 std::vector<Plugin::PresetRecord>
2890 LV2PluginInfo::get_presets (bool /*user_only*/) const
2892 std::vector<Plugin::PresetRecord> p;
2893 #ifndef NO_PLUGIN_STATE
2894 const LilvPlugin* lp = NULL;
2897 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2898 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2899 if (!uri) { throw failed_constructor(); }
2900 lp = lilv_plugins_get_by_uri(plugins, uri);
2901 if (!lp) { throw failed_constructor(); }
2902 lilv_node_free(uri);
2903 } catch (failed_constructor& err) {
2907 // see LV2Plugin::find_presets
2908 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
2909 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
2910 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
2912 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
2913 LILV_FOREACH(nodes, i, presets) {
2914 const LilvNode* preset = lilv_nodes_get(presets, i);
2915 lilv_world_load_resource(_world.world, preset);
2916 LilvNode* name = get_value(_world.world, preset, rdfs_label);
2917 bool userpreset = true; // TODO
2919 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
2920 lilv_node_free(name);
2923 lilv_nodes_free(presets);
2924 lilv_node_free(rdfs_label);
2925 lilv_node_free(pset_Preset);
2926 lilv_node_free(lv2_appliesTo);
2932 LV2PluginInfo::in_category (const std::string &c) const
2934 // TODO use untranslated lilv_plugin_get_class()
2935 // match gtk2_ardour/plugin_selector.cc
2936 if (category == c) {
2943 LV2PluginInfo::is_instrument () const
2945 if (category == "Instrument") {
2949 /* until we make sure that category remains untranslated in the lv2.ttl spec
2950 * and until most instruments also classify themselves as such, there's a 2nd check:
2952 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2960 LV2PluginInfo::discover()
2963 world.load_bundled_plugins();
2964 _world.load_bundled_plugins(true);
2966 PluginInfoList* plugs = new PluginInfoList;
2967 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2969 LILV_FOREACH(plugins, i, plugins) {
2970 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2971 const LilvNode* pun = lilv_plugin_get_uri(p);
2973 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2975 LilvNode* name = lilv_plugin_get_name(p);
2976 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2977 warning << "Ignoring invalid LV2 plugin "
2978 << lilv_node_as_string(lilv_plugin_get_uri(p))
2983 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2984 warning << string_compose(
2985 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2986 lilv_node_as_string(name)) << endmsg;
2987 lilv_node_free(name);
2991 #ifdef HAVE_LV2_1_2_0
2992 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2993 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2994 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2996 warning << string_compose(
2997 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2998 lilv_node_as_string(name)) << endmsg;
2999 lilv_nodes_free(required_features);
3000 lilv_node_free(name);
3003 lilv_nodes_free(required_features);
3008 info->name = string(lilv_node_as_string(name));
3009 lilv_node_free(name);
3010 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3012 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3013 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3014 info->category = lilv_node_as_string(label);
3016 LilvNode* author_name = lilv_plugin_get_author_name(p);
3017 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3018 lilv_node_free(author_name);
3020 info->path = "/NOPATH"; // Meaningless for LV2
3022 /* count atom-event-ports that feature
3023 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3025 * TODO: nicely ask drobilla to make a lilv_ call for that
3027 int count_midi_out = 0;
3028 int count_midi_in = 0;
3029 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3030 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3031 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3032 LilvNodes* buffer_types = lilv_port_get_value(
3033 p, port, world.atom_bufferType);
3034 LilvNodes* atom_supports = lilv_port_get_value(
3035 p, port, world.atom_supports);
3037 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3038 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3039 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3042 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3046 lilv_nodes_free(buffer_types);
3047 lilv_nodes_free(atom_supports);
3051 info->n_inputs.set_audio(
3052 lilv_plugin_get_num_ports_of_class(
3053 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3054 info->n_inputs.set_midi(
3055 lilv_plugin_get_num_ports_of_class(
3056 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3059 info->n_outputs.set_audio(
3060 lilv_plugin_get_num_ports_of_class(
3061 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3062 info->n_outputs.set_midi(
3063 lilv_plugin_get_num_ports_of_class(
3064 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3067 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3068 info->index = 0; // Meaningless for LV2
3070 plugs->push_back(info);