2 Copyright (C) 2008-2012 Paul Davis
3 Author: David Robillard
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 #include "pbd/gstdio_compat.h"
30 #include <glib/gprintf.h>
33 #include <boost/utility.hpp>
35 #include "pbd/file_utils.h"
36 #include "pbd/stl_delete.h"
37 #include "pbd/compose.h"
38 #include "pbd/error.h"
39 #include "pbd/locale_guard.h"
40 #include "pbd/pthread_utils.h"
41 #include "pbd/replace_all.h"
42 #include "pbd/xml++.h"
44 #ifdef PLATFORM_WINDOWS
45 #include <shlobj.h> // CSIDL_*
46 #include "pbd/windows_special_dirs.h"
50 #include "libardour-config.h"
53 #include "ardour/audio_buffer.h"
54 #include "ardour/audioengine.h"
55 #include "ardour/directory_names.h"
56 #include "ardour/debug.h"
57 #include "ardour/lv2_plugin.h"
58 #include "ardour/midi_patch_manager.h"
59 #include "ardour/session.h"
60 #include "ardour/tempo.h"
61 #include "ardour/types.h"
62 #include "ardour/utils.h"
63 #include "ardour/worker.h"
64 #include "ardour/search_paths.h"
69 #include <lilv/lilv.h>
71 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
72 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
73 #include "lv2/lv2plug.in/ns/ext/log/log.h"
74 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
75 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
76 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
77 #include "lv2/lv2plug.in/ns/ext/state/state.h"
78 #include "lv2/lv2plug.in/ns/ext/time/time.h"
79 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
80 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
81 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
82 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
83 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
84 #include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
86 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
87 #include "lv2/lv2plug.in/ns/ext/options/options.h"
90 #include "lv2_evbuf.h"
93 #include <suil/suil.h>
96 // Compatibility for old LV2
97 #ifndef LV2_ATOM_CONTENTS_CONST
98 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
99 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
101 #ifndef LV2_ATOM_BODY_CONST
102 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
104 #ifndef LV2_PATCH__property
105 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
107 #ifndef LV2_PATCH__value
108 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
110 #ifndef LV2_PATCH__writable
111 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
114 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
115 This needs to be roughly the number of cycles the UI will get around to
116 actually processing the traffic. Lower values are flakier but save memory.
118 static const size_t NBUFS = 4;
121 using namespace ARDOUR;
124 bool LV2Plugin::force_state_save = false;
126 class LV2World : boost::noncopyable {
131 void load_bundled_plugins(bool verbose=false);
135 LilvNode* atom_AtomPort;
136 LilvNode* atom_Chunk;
137 LilvNode* atom_Sequence;
138 LilvNode* atom_bufferType;
139 LilvNode* atom_eventTransfer;
140 LilvNode* atom_supports;
141 LilvNode* ev_EventPort;
142 LilvNode* ext_logarithmic;
143 LilvNode* ext_notOnGUI;
144 LilvNode* ext_expensive;
145 LilvNode* ext_causesArtifacts;
146 LilvNode* ext_notAutomatic;
147 LilvNode* ext_rangeSteps;
148 LilvNode* groups_group;
149 LilvNode* groups_element;
150 LilvNode* lv2_AudioPort;
151 LilvNode* lv2_ControlPort;
152 LilvNode* lv2_InputPort;
153 LilvNode* lv2_OutputPort;
154 LilvNode* lv2_designation;
155 LilvNode* lv2_enumeration;
156 LilvNode* lv2_freewheeling;
157 LilvNode* lv2_inPlaceBroken;
158 LilvNode* lv2_isSideChain;
160 LilvNode* lv2_integer;
161 LilvNode* lv2_default;
162 LilvNode* lv2_minimum;
163 LilvNode* lv2_maximum;
164 LilvNode* lv2_reportsLatency;
165 LilvNode* lv2_sampleRate;
166 LilvNode* lv2_toggled;
167 LilvNode* midi_MidiEvent;
168 LilvNode* rdfs_comment;
169 LilvNode* rdfs_label;
170 LilvNode* rdfs_range;
171 LilvNode* rsz_minimumSize;
172 LilvNode* time_Position;
174 LilvNode* ui_external;
175 LilvNode* ui_externalkx;
178 LilvNode* units_unit;
179 LilvNode* units_render;
180 LilvNode* units_midiNote;
181 LilvNode* patch_writable;
182 LilvNode* patch_Message;
183 #ifdef HAVE_LV2_1_2_0
184 LilvNode* bufz_powerOf2BlockLength;
185 LilvNode* bufz_fixedBlockLength;
186 LilvNode* bufz_nominalBlockLength;
187 LilvNode* bufz_coarseBlockLength;
190 #ifdef HAVE_LV2_1_10_0
192 LilvNode* atom_float;
193 LilvNode* atom_object; // new in 1.8
194 LilvNode* atom_vector;
197 LilvNode* lv2_noSampleAccurateCtrl;
198 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
199 LilvNode* auto_automation_control; // atom:supports
200 LilvNode* auto_automation_controlled; // lv2:portProperty
201 LilvNode* auto_automation_controller; // lv2:portProperty
202 LilvNode* inline_display_in_gui; // lv2:optionalFeature
206 bool _bundle_checked;
209 static LV2World _world;
211 /* worker extension */
213 /** Called by the plugin to schedule non-RT work. */
214 static LV2_Worker_Status
215 work_schedule(LV2_Worker_Schedule_Handle handle,
219 return (((Worker*)handle)->schedule(size, data)
221 : LV2_WORKER_ERR_UNKNOWN);
224 /** Called by the plugin to respond to non-RT work. */
225 static LV2_Worker_Status
226 work_respond(LV2_Worker_Respond_Handle handle,
230 return (((Worker*)handle)->respond(size, data)
232 : LV2_WORKER_ERR_UNKNOWN);
236 /* inline display extension */
238 LV2Plugin::queue_draw (LV2_Inline_Display_Handle handle)
240 LV2Plugin* plugin = (LV2Plugin*)handle;
241 plugin->QueueDraw(); /* EMIT SIGNAL */
245 LV2Plugin::midnam_update (LV2_Midnam_Handle handle)
247 LV2Plugin* plugin = (LV2Plugin*)handle;
248 plugin->_midnam_dirty = true;
249 plugin->UpdateMidnam (); /* EMIT SIGNAL */
253 LV2Plugin::bankpatch_notify (LV2_BankPatch_Handle handle, uint8_t chn, uint32_t bank, uint8_t pgm)
255 LV2Plugin* plugin = (LV2Plugin*)handle;
259 plugin->seen_bankpatch = true;
260 if (pgm > 127 || bank > 16383) {
261 plugin->_bankpatch[chn] = UINT32_MAX;
263 plugin->_bankpatch[chn] = (bank << 7) | pgm;
265 plugin->BankPatchChange (chn); /* EMIT SIGNAL */
272 log_vprintf(LV2_Log_Handle /*handle*/,
278 const int ret = g_vasprintf(&str, fmt, args);
279 /* strip trailing whitespace */
280 while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
281 str[strlen (str) - 1] = '\0';
283 if (strlen (str) == 0) {
287 if (type == URIMap::instance().urids.log_Error) {
288 error << str << endmsg;
289 } else if (type == URIMap::instance().urids.log_Warning) {
290 warning << str << endmsg;
291 } else if (type == URIMap::instance().urids.log_Note) {
292 info << str << endmsg;
293 } else if (type == URIMap::instance().urids.log_Trace) {
294 DEBUG_TRACE(DEBUG::LV2, str);
300 log_printf(LV2_Log_Handle handle,
302 const char* fmt, ...)
306 const int ret = log_vprintf(handle, type, fmt, args);
311 struct LV2Plugin::Impl {
312 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
314 #ifdef HAVE_LV2_1_2_0
319 #ifdef HAVE_LV2_1_2_0
328 /** Find the LV2 input port with the given designation.
329 * If found, bufptrs[port_index] will be set to bufptr.
331 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
333 const LilvPlugin* plugin;
335 const LilvNode* ui_type;
338 LilvInstance* instance;
339 const LV2_Worker_Interface* work_iface;
340 #ifdef HAVE_LV2_1_2_0
341 const LV2_Options_Interface* opts_iface;
344 LV2_Atom_Forge forge;
345 LV2_Atom_Forge ui_forge;
346 int32_t block_length;
347 #ifdef HAVE_LV2_1_2_0
348 LV2_Options_Option* options;
351 LV2_Inline_Display* queue_draw;
353 LV2_BankPatch* bankpatch;
357 LV2Plugin::LV2Plugin (AudioEngine& engine,
359 const void* c_plugin,
361 : Plugin (engine, session)
366 , _state_worker(NULL)
368 , _patch_port_in_index((uint32_t)-1)
369 , _patch_port_out_index((uint32_t)-1)
370 , _uri_map(URIMap::instance())
371 , _no_sample_accurate_ctrl (false)
373 init(c_plugin, rate);
376 LV2Plugin::LV2Plugin (const LV2Plugin& other)
382 , _state_worker(NULL)
383 , _insert_id(other._insert_id)
384 , _patch_port_in_index((uint32_t)-1)
385 , _patch_port_out_index((uint32_t)-1)
386 , _uri_map(URIMap::instance())
387 , _no_sample_accurate_ctrl (false)
389 init(other._impl->plugin, other._sample_rate);
391 for (uint32_t i = 0; i < parameter_count(); ++i) {
392 _control_data[i] = other._shadow_data[i];
393 _shadow_data[i] = other._shadow_data[i];
398 LV2Plugin::init(const void* c_plugin, samplecnt_t rate)
400 DEBUG_TRACE(DEBUG::LV2, "init\n");
402 _impl->plugin = (const LilvPlugin*)c_plugin;
404 _impl->ui_type = NULL;
409 _atom_ev_buffers = 0;
411 _bpm_control_port = 0;
412 _freewheel_control_port = 0;
413 _latency_control_port = 0;
414 _next_cycle_start = std::numeric_limits<samplepos_t>::max();
415 _next_cycle_speed = 1.0;
416 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
418 _was_activated = false;
419 _has_state_interface = false;
420 _can_write_automation = false;
422 _inline_display_in_gui = false;
425 _current_latency = 0;
426 _impl->block_length = _session.get_block_size();
428 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
429 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
430 _make_path_feature.URI = LV2_STATE__makePath;
431 _log_feature.URI = LV2_LOG__log;
432 _work_schedule_feature.URI = LV2_WORKER__schedule;
433 _work_schedule_feature.data = NULL;
434 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
435 _def_state_feature.data = NULL;
437 const LilvPlugin* plugin = _impl->plugin;
439 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
440 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
441 _has_state_interface =
442 // What plugins should have (lv2:extensionData state:Interface)
443 lilv_plugin_has_extension_data(plugin, state_iface_uri)
444 // What some outdated/incorrect ones have
445 || lilv_plugin_has_feature(plugin, state_uri);
446 lilv_node_free(state_uri);
447 lilv_node_free(state_iface_uri);
449 _features = (LV2_Feature**)calloc(14, sizeof(LV2_Feature*));
450 _features[0] = &_instance_access_feature;
451 _features[1] = &_data_access_feature;
452 _features[2] = &_make_path_feature;
453 _features[3] = _uri_map.uri_map_feature();
454 _features[4] = _uri_map.urid_map_feature();
455 _features[5] = _uri_map.urid_unmap_feature();
456 _features[6] = &_log_feature;
458 unsigned n_features = 7;
459 #ifdef HAVE_LV2_1_2_0
460 _features[n_features++] = &_def_state_feature;
463 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
464 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
467 _impl->queue_draw = (LV2_Inline_Display*)
468 malloc (sizeof(LV2_Inline_Display));
469 _impl->queue_draw->handle = this;
470 _impl->queue_draw->queue_draw = queue_draw;
472 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
473 _queue_draw_feature.data = _impl->queue_draw;
474 _features[n_features++] = &_queue_draw_feature;
476 _impl->midnam = (LV2_Midnam*)
477 malloc (sizeof(LV2_Midnam));
478 _impl->midnam->handle = this;
479 _impl->midnam->update = midnam_update;
481 _midnam_feature.URI = LV2_MIDNAM__update;
482 _midnam_feature.data = _impl->midnam;
483 _features[n_features++] = &_midnam_feature;
485 _impl->bankpatch = (LV2_BankPatch*)
486 malloc (sizeof(LV2_BankPatch));
487 _impl->bankpatch->handle = this;
488 _impl->bankpatch->notify = bankpatch_notify;
490 _bankpatch_feature.URI = LV2_BANKPATCH__notify;
491 _bankpatch_feature.data = _impl->bankpatch;
492 _features[n_features++] = &_bankpatch_feature;
495 #ifdef HAVE_LV2_1_2_0
496 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
497 static const int32_t _min_block_length = 1; // may happen during split-cycles
498 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
499 static const int32_t rt_policy = PBD_SCHED_FIFO;
500 static const int32_t rt_priority = pbd_absolute_rt_priority (PBD_SCHED_FIFO, AudioEngine::instance()->client_real_time_priority () - 2);
501 /* Consider updating max-block-size whenever the buffersize changes.
502 * It requires re-instantiating the plugin (which is a non-realtime operation),
503 * so it should be done lightly and only for plugins that require it.
505 * given that the block-size can change at any time (split-cycles) ardour currently
506 * does not support plugins that require bufz_fixedBlockLength.
508 LV2_Options_Option options[] = {
509 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
510 sizeof(int32_t), atom_Int, &_min_block_length },
511 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
512 sizeof(int32_t), atom_Int, &_max_block_length },
513 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
514 sizeof(int32_t), atom_Int, &_seq_size },
515 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
516 sizeof(int32_t), atom_Int, &_impl->block_length },
517 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://ardour.org/lv2/threads/#schedPolicy"),
518 sizeof(int32_t), atom_Int, &rt_policy },
519 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://ardour.org/lv2/threads/#schedPriority"),
520 sizeof(int32_t), atom_Int, &rt_priority },
521 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
524 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
525 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
527 _options_feature.URI = LV2_OPTIONS__options;
528 _options_feature.data = _impl->options;
529 _features[n_features++] = &_options_feature;
533 seen_bankpatch = false;
534 for (uint32_t chn = 0; chn < 16; ++chn) {
535 _bankpatch[chn] = UINT32_MAX;
539 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
540 sizeof(LV2_State_Make_Path));
541 make_path->handle = this;
542 make_path->path = &lv2_state_make_path;
543 _make_path_feature.data = make_path;
545 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
547 log->printf = &log_printf;
548 log->vprintf = &log_vprintf;
549 _log_feature.data = log;
551 const size_t ring_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
552 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
553 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
554 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
555 sizeof(LV2_Worker_Schedule));
556 _worker = new Worker(this, ring_size);
557 schedule->handle = _worker;
558 schedule->schedule_work = work_schedule;
559 _work_schedule_feature.data = schedule;
560 _features[n_features++] = &_work_schedule_feature;
562 lilv_node_free(worker_schedule);
564 if (_has_state_interface) {
565 // Create a non-threaded worker for use by state restore
566 _state_worker = new Worker(this, ring_size, false);
569 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
570 _impl->name = lilv_plugin_get_name(plugin);
571 _impl->author = lilv_plugin_get_author_name(plugin);
573 if (_impl->instance == 0) {
574 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
575 throw failed_constructor();
578 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
579 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
580 _data_access_feature.data = &_data_access_extension_data;
582 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
583 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
584 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
585 LV2_WORKER__interface);
587 lilv_node_free(worker_iface_uri);
590 #ifdef HAVE_LV2_1_2_0
591 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
592 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
593 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
594 LV2_OPTIONS__interface);
596 lilv_node_free(options_iface_uri);
600 _display_interface = (const LV2_Inline_Display_Interface*)
601 extension_data (LV2_INLINEDISPLAY__interface);
603 _midname_interface = (const LV2_Midnam_Interface*)
604 extension_data (LV2_MIDNAM__interface);
605 if (_midname_interface) {
606 _midnam_dirty = true;
611 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
612 error << string_compose(
613 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
614 lilv_node_as_string(_impl->name)) << endmsg;
615 lilv_node_free(_impl->name);
616 lilv_node_free(_impl->author);
617 throw failed_constructor();
620 #ifdef HAVE_LV2_1_2_0
621 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
622 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
623 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
625 error << string_compose(
626 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
627 lilv_node_as_string(_impl->name)) << endmsg;
628 lilv_node_free(_impl->name);
629 lilv_node_free(_impl->author);
630 lilv_nodes_free(required_features);
631 throw failed_constructor();
633 lilv_nodes_free(required_features);
636 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
637 #ifdef HAVE_LV2_1_2_0
638 if (lilv_nodes_contains (optional_features, _world.bufz_coarseBlockLength)) {
639 _no_sample_accurate_ctrl = true;
643 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
644 /* deprecated 2016-Sep-18 in favor of bufz_coarseBlockLength */
645 _no_sample_accurate_ctrl = true;
647 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
648 _can_write_automation = true;
650 if (lilv_nodes_contains (optional_features, _world.inline_display_in_gui)) {
651 _inline_display_in_gui = true;
653 lilv_nodes_free(optional_features);
656 #ifdef HAVE_LILV_0_16_0
657 // Load default state
659 /* immediately schedule any work,
660 * so that state restore later will not find a busy
661 * worker. latency_compute_run() flushes any replies
663 _worker->set_synchronous(true);
665 LilvState* state = lilv_state_new_from_world(
666 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
667 if (state && _has_state_interface) {
668 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
670 lilv_state_free(state);
675 const uint32_t num_ports = this->num_ports();
676 for (uint32_t i = 0; i < num_ports; ++i) {
677 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
679 size_t minimumSize = 0;
681 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
682 flags |= PORT_OUTPUT;
683 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
686 error << string_compose(
687 "LV2: \"%1\" port %2 is neither input nor output",
688 lilv_node_as_string(_impl->name), i) << endmsg;
689 throw failed_constructor();
692 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
693 flags |= PORT_CONTROL;
694 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
696 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
698 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
699 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
700 LilvNodes* buffer_types = lilv_port_get_value(
701 _impl->plugin, port, _world.atom_bufferType);
702 LilvNodes* atom_supports = lilv_port_get_value(
703 _impl->plugin, port, _world.atom_supports);
705 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
706 flags |= PORT_SEQUENCE;
707 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
710 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
711 flags |= PORT_POSITION;
714 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
715 flags |= PORT_AUTOCTRL;
718 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
719 flags |= PORT_PATCHMSG;
720 if (flags & PORT_INPUT) {
721 _patch_port_in_index = i;
723 _patch_port_out_index = i;
727 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
728 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
729 if (min_size && lilv_node_is_int(min_size)) {
730 minimumSize = lilv_node_as_int(min_size);
732 lilv_nodes_free(min_size_v);
733 lilv_nodes_free(buffer_types);
734 lilv_nodes_free(atom_supports);
736 error << string_compose(
737 "LV2: \"%1\" port %2 has no known data type",
738 lilv_node_as_string(_impl->name), i) << endmsg;
739 throw failed_constructor();
742 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
743 if (lilv_port_has_property(_impl->plugin, port, _world.ext_causesArtifacts)) {
744 flags |= PORT_NOAUTO;
746 if (lilv_port_has_property(_impl->plugin, port, _world.ext_notAutomatic)) {
747 flags |= PORT_NOAUTO;
749 if (lilv_port_has_property(_impl->plugin, port, _world.ext_expensive)) {
750 flags |= PORT_NOAUTO;
754 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
755 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
756 flags |= PORT_CTRLED;
759 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controller)) {
760 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
761 flags |= PORT_CTRLER;
766 _port_flags.push_back(flags);
767 _port_minimumSize.push_back(minimumSize);
768 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
771 _control_data = new float[num_ports];
772 _shadow_data = new float[num_ports];
773 _defaults = new float[num_ports];
774 _ev_buffers = new LV2_Evbuf*[num_ports];
775 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
777 const bool latent = lilv_plugin_has_latency(plugin);
778 const uint32_t latency_index = (latent)
779 ? lilv_plugin_get_latency_port_index(plugin)
782 // Build an array of pointers to special parameter buffers
783 void*** params = new void**[num_ports];
784 for (uint32_t i = 0; i < num_ports; ++i) {
787 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
788 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
790 for (uint32_t i = 0; i < num_ports; ++i) {
791 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
792 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
794 // Store index in map so we can look up index by symbol
795 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
797 // Get range and default value if applicable
798 if (parameter_is_control(i)) {
800 lilv_port_get_range(plugin, port, &def, NULL, NULL);
801 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
802 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
803 _defaults[i] *= _session.sample_rate ();
807 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
809 if (latent && i == latency_index) {
811 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
812 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
813 _latency_control_port = &_control_data[i];
814 *_latency_control_port = 0;
817 if (parameter_is_input(i)) {
818 _shadow_data[i] = default_value(i);
820 *params[i] = (void*)&_shadow_data[i];
830 LilvUIs* uis = lilv_plugin_get_uis(plugin);
831 if (lilv_uis_size(uis) > 0) {
833 // Look for embeddable UI
834 LILV_FOREACH(uis, u, uis) {
835 const LilvUI* this_ui = lilv_uis_get(uis, u);
836 const LilvNode* this_ui_type = NULL;
837 if (lilv_ui_is_supported(this_ui,
841 // TODO: Multiple UI support
843 _impl->ui_type = this_ui_type;
848 // Look for Gtk native UI
849 LILV_FOREACH(uis, i, uis) {
850 const LilvUI* ui = lilv_uis_get(uis, i);
851 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
853 _impl->ui_type = _world.ui_GtkUI;
859 // If Gtk UI is not available, try to find external UI
861 LILV_FOREACH(uis, i, uis) {
862 const LilvUI* ui = lilv_uis_get(uis, i);
863 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
865 _impl->ui_type = _world.ui_external;
868 if (lilv_ui_is_a(ui, _world.ui_external)) {
870 _impl->ui_type = _world.ui_external;
876 load_supported_properties(_property_descriptors);
877 allocate_atom_event_buffers();
878 latency_compute_run();
882 LV2Plugin::set_block_size (pframes_t nframes)
884 #ifdef HAVE_LV2_1_2_0
885 if (_impl->opts_iface) {
886 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
887 _impl->block_length = nframes;
888 LV2_Options_Option block_size_option = {
889 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
890 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
892 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
899 LV2Plugin::requires_fixed_sized_buffers () const
901 /* This controls if Ardour will split the plugin's run()
902 * on automation events in order to pass sample-accurate automation
903 * via standard control-ports.
905 * When returning true Ardour will *not* sub-divide the process-cycle.
906 * Automation events that happen between cycle-start and cycle-end will be
907 * ignored (ctrl values are interpolated to cycle-start).
908 * NB. Atom Sequences are still sample accurate.
910 * Note: This does not guarantee a fixed block-size.
911 * e.g The process cycle may be split when looping, also
912 * the period-size may change any time: see set_block_size()
914 if (get_info()->n_inputs.n_midi() > 0) {
915 /* we don't yet implement midi buffer offsets (for split cycles).
916 * Also connect_and_run() also uses _session.transport_sample() directly
917 * (for BBT) which is not offset for plugin cycle split.
921 return _no_sample_accurate_ctrl;
924 LV2Plugin::~LV2Plugin ()
926 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
933 std::stringstream ss;
936 MIDI::Name::MidiPatchManager::instance().remove_custom_midnam (ss.str());
940 lilv_instance_free(_impl->instance);
941 lilv_state_free(_impl->state);
942 lilv_node_free(_impl->name);
943 lilv_node_free(_impl->author);
944 #ifdef HAVE_LV2_1_2_0
945 free(_impl->options);
948 free(_impl->queue_draw);
950 free(_impl->bankpatch);
954 free(_log_feature.data);
955 free(_make_path_feature.data);
956 free(_work_schedule_feature.data);
961 delete _state_worker;
963 if (_atom_ev_buffers) {
964 LV2_Evbuf** b = _atom_ev_buffers;
969 free(_atom_ev_buffers);
972 delete [] _control_data;
973 delete [] _shadow_data;
975 delete [] _ev_buffers;
980 LV2Plugin::is_external_ui() const
985 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
989 LV2Plugin::is_external_kx() const
994 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
998 LV2Plugin::ui_is_resizable () const
1000 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
1001 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
1002 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
1003 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
1005 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
1006 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
1008 lilv_nodes_free(nrs_matches);
1009 lilv_nodes_free(fs_matches);
1010 lilv_node_free(nrs);
1014 return !fs_matches && !nrs_matches;
1019 LV2Plugin::has_inline_display () {
1020 return _display_interface ? true : false;
1024 LV2Plugin::inline_display_in_gui () {
1025 return _inline_display_in_gui;
1028 Plugin::Display_Image_Surface*
1029 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
1030 if (_display_interface) {
1031 /* Plugin::Display_Image_Surface is identical to
1032 * LV2_Inline_Display_Image_Surface */
1033 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
1039 LV2Plugin::has_midnam () {
1040 return _midname_interface ? true : false;
1044 LV2Plugin::read_midnam () {
1046 if (!_midname_interface || !_midnam_dirty) {
1049 char* midnam = _midname_interface->midnam ((void*)_impl->instance->lv2_handle);
1051 std::stringstream ss;
1054 rv = MIDI::Name::MidiPatchManager::instance().update_custom_midnam (ss.str(), midnam);
1058 info << string_compose(_("LV2: update midnam for plugin '%1'"), name ()) << endmsg;
1060 warning << string_compose(_("LV2: Failed to parse midnam of plugin '%1'"), name ()) << endmsg;
1063 _midname_interface->free (midnam);
1066 _midnam_dirty = false;
1072 LV2Plugin::midnam_model () {
1074 if (!_midname_interface) {
1077 char* model = _midname_interface->model ((void*)_impl->instance->lv2_handle);
1081 _midname_interface->free (model);
1087 LV2Plugin::unique_id() const
1089 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1093 LV2Plugin::uri() const
1095 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1099 LV2Plugin::label() const
1101 return lilv_node_as_string(_impl->name);
1105 LV2Plugin::name() const
1107 return lilv_node_as_string(_impl->name);
1111 LV2Plugin::maker() const
1113 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
1117 LV2Plugin::num_ports() const
1119 return lilv_plugin_get_num_ports(_impl->plugin);
1123 LV2Plugin::parameter_count() const
1125 return lilv_plugin_get_num_ports(_impl->plugin);
1129 LV2Plugin::default_value(uint32_t port)
1131 return _defaults[port];
1135 LV2Plugin::port_symbol(uint32_t index) const
1137 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
1139 error << name() << ": Invalid port index " << index << endmsg;
1142 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
1143 return lilv_node_as_string(sym);
1147 LV2Plugin::port_index (const char* symbol) const
1149 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
1150 if (i != _port_indices.end()) {
1153 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
1154 return (uint32_t)-1;
1159 LV2Plugin::set_parameter(uint32_t which, float val)
1161 DEBUG_TRACE(DEBUG::LV2, string_compose(
1162 "%1 set parameter %2 to %3\n", name(), which, val));
1164 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
1165 if (get_parameter (which) == val) {
1169 _shadow_data[which] = val;
1171 warning << string_compose(
1172 _("Illegal parameter number used with plugin \"%1\". "
1173 "This is a bug in either %2 or the LV2 plugin <%3>"),
1174 name(), PROGRAM_NAME, unique_id()) << endmsg;
1177 Plugin::set_parameter(which, val);
1181 LV2Plugin::get_parameter(uint32_t which) const
1183 if (parameter_is_input(which)) {
1184 return (float)_shadow_data[which];
1186 return (float)_control_data[which];
1192 LV2Plugin::get_docs() const
1194 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1196 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1197 lilv_nodes_free(comments);
1205 LV2Plugin::get_parameter_docs(uint32_t which) const
1207 LilvNodes* comments = lilv_port_get_value(
1209 lilv_plugin_get_port_by_index(_impl->plugin, which),
1210 _world.rdfs_comment);
1213 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1214 lilv_nodes_free(comments);
1222 LV2Plugin::get_layout (uint32_t which, UILayoutHint& h) const
1224 /// TODO lookup port-properties
1225 if (unique_id () != "urn:ardour:a-eq") {
1230 case 0: h.x0 = 0; h.x1 = 1; h.y0 = 2; h.y1 = 3; break; // Frequency L
1231 case 1: h.x0 = 0; h.x1 = 1; h.y0 = 0; h.y1 = 1; break; // Gain L
1232 case 17: h.x0 = 0; h.x1 = 1; h.y0 = 5; h.y1 = 6; break; // enable L
1234 case 2: h.x0 = 1; h.x1 = 3; h.y0 = 2; h.y1 = 3; break; // Frequency 1
1235 case 3: h.x0 = 1; h.x1 = 3; h.y0 = 0; h.y1 = 1; break; // Gain 1
1236 case 4: h.x0 = 1; h.x1 = 3; h.y0 = 1; h.y1 = 2; break; // Bandwidth 1
1237 case 18: h.x0 = 1; h.x1 = 4; h.y0 = 5; h.y1 = 6; break; // enable 1
1239 case 5: h.x0 = 4; h.x1 = 6; h.y0 = 2; h.y1 = 3; break; // Frequency 2
1240 case 6: h.x0 = 4; h.x1 = 6; h.y0 = 0; h.y1 = 1; break; // Gain 2
1241 case 7: h.x0 = 4; h.x1 = 6; h.y0 = 1; h.y1 = 2; break; // Bandwidth 2
1242 case 19: h.x0 = 4; h.x1 = 7; h.y0 = 5; h.y1 = 6; break; // enable 2
1244 case 8: h.x0 = 7; h.x1 = 9; h.y0 = 2; h.y1 = 3; break; // Frequency 3
1245 case 9: h.x0 = 7; h.x1 = 9; h.y0 = 0; h.y1 = 1; break; // Gain 3
1246 case 10: h.x0 = 7; h.x1 = 9; h.y0 = 1; h.y1 = 2; break; // Bandwidth 3
1247 case 20: h.x0 = 7; h.x1 = 10; h.y0 = 5; h.y1 = 6; break; // enable 3
1249 case 11: h.x0 = 10; h.x1 = 12; h.y0 = 2; h.y1 = 3; break; // Frequency 4
1250 case 12: h.x0 = 10; h.x1 = 12; h.y0 = 0; h.y1 = 1; break; // Gain 4
1251 case 13: h.x0 = 10; h.x1 = 12; h.y0 = 1; h.y1 = 2; break; // Bandwidth 4
1252 case 21: h.x0 = 10; h.x1 = 13; h.y0 = 5; h.y1 = 6; break; // enable 4
1254 case 14: h.x0 = 13; h.x1 = 14; h.y0 = 2; h.y1 = 3; break; // Frequency H
1255 case 15: h.x0 = 13; h.x1 = 14; h.y0 = 0; h.y1 = 1; break; // Gain H
1256 case 22: h.x0 = 13; h.x1 = 14; h.y0 = 5; h.y1 = 6; break; // enable H
1258 case 16: h.x0 = 14; h.x1 = 15; h.y0 = 1; h.y1 = 3; break; // Master Gain
1259 case 23: h.x0 = 14; h.x1 = 15; h.y0 = 5; h.y1 = 6; break; // Master Enable
1267 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1270 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1271 if (parameter_is_control(x)) {
1283 LV2Plugin::extension_data(const char* uri) const
1285 return lilv_instance_get_extension_data(_impl->instance, uri);
1289 LV2Plugin::c_plugin()
1291 return _impl->plugin;
1297 return (const void*)_impl->ui;
1301 LV2Plugin::c_ui_type()
1303 return (const void*)_impl->ui_type;
1306 /** Directory for all plugin state. */
1308 LV2Plugin::plugin_dir() const
1310 if (!_plugin_state_dir.empty ()){
1311 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1313 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1317 /** Directory for files created by the plugin (except during save). */
1319 LV2Plugin::scratch_dir() const
1321 return Glib::build_filename(plugin_dir(), "scratch");
1324 /** Directory for snapshots of files in the scratch directory. */
1326 LV2Plugin::file_dir() const
1328 return Glib::build_filename(plugin_dir(), "files");
1331 /** Directory to save state snapshot version @c num into. */
1333 LV2Plugin::state_dir(unsigned num) const
1335 return Glib::build_filename(plugin_dir(), string("state") + PBD::to_string (num));
1338 /** Implementation of state:makePath for files created at instantiation time.
1339 * Note this is not used for files created at save time (Lilv deals with that).
1342 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1345 LV2Plugin* me = (LV2Plugin*)handle;
1346 if (me->_insert_id == PBD::ID("0")) {
1347 warning << string_compose(
1348 "File path \"%1\" requested but LV2 %2 has no insert ID",
1349 path, me->name()) << endmsg;
1350 return g_strdup(path);
1353 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1354 const std::string dirname = Glib::path_get_dirname(abs_path);
1355 g_mkdir_with_parents(dirname.c_str(), 0744);
1357 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1360 return g_strndup(abs_path.c_str(), abs_path.length());
1364 LV2Plugin::add_state(XMLNode* root) const
1366 assert(_insert_id != PBD::ID("0"));
1371 for (uint32_t i = 0; i < parameter_count(); ++i) {
1372 if (parameter_is_input(i) && parameter_is_control(i)) {
1373 child = new XMLNode("Port");
1374 child->set_property("symbol", port_symbol(i));
1375 child->set_property("value", _shadow_data[i]);
1376 root->add_child_nocopy(*child);
1380 if (!_plugin_state_dir.empty()) {
1381 root->set_property("template-dir", _plugin_state_dir);
1384 if (_has_state_interface) {
1385 // Provisionally increment state version and create directory
1386 const std::string new_dir = state_dir(++_state_version);
1387 // and keep track of it (for templates & archive)
1388 unsigned int saved_state = _state_version;;
1389 g_mkdir_with_parents(new_dir.c_str(), 0744);
1391 std::string xternal_dir = _session.externals_dir ();
1393 if (!_plugin_state_dir.empty()) {
1394 xternal_dir = Glib::build_filename (_plugin_state_dir, externals_dir_name);
1395 g_mkdir_with_parents(xternal_dir.c_str(), 0744);
1398 LilvState* state = lilv_state_new_from_instance(
1401 _uri_map.urid_map(),
1402 scratch_dir().c_str(),
1404 xternal_dir.c_str(),
1407 const_cast<LV2Plugin*>(this),
1411 if (!_plugin_state_dir.empty() || force_state_save
1413 || !lilv_state_equals(state, _impl->state)) {
1414 lilv_state_save(_world.world,
1415 _uri_map.urid_map(),
1416 _uri_map.urid_unmap(),
1422 if (force_state_save) {
1423 // archive or save-as
1424 lilv_state_free(state);
1427 else if (_plugin_state_dir.empty()) {
1428 // normal session save
1429 lilv_state_free(_impl->state);
1430 _impl->state = state;
1432 // template save (dedicated state-dir)
1433 lilv_state_free(state);
1434 g_rmdir (xternal_dir.c_str()); // try remove unused dir
1438 // State is identical, decrement version and nuke directory
1439 lilv_state_free(state);
1440 PBD::remove_directory(new_dir);
1442 saved_state = _state_version;
1445 root->set_property("state-dir", string("state") + PBD::to_string (saved_state));
1449 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1451 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1453 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1455 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1456 lilv_nodes_free(vs);
1463 LV2Plugin::find_presets()
1465 /* see also LV2PluginInfo::get_presets */
1466 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1467 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1468 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1469 LilvNode* rdfs_comment = lilv_new_uri(_world.world, LILV_NS_RDFS "comment");
1471 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1472 LILV_FOREACH(nodes, i, presets) {
1473 const LilvNode* preset = lilv_nodes_get(presets, i);
1474 lilv_world_load_resource(_world.world, preset);
1475 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1476 LilvNode* comment = get_value(_world.world, preset, rdfs_comment);
1477 /* TODO properly identify user vs factory presets.
1478 * here's an indirect condition: only factory presets can have comments
1480 bool userpreset = comment ? false : true;
1482 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1483 Plugin::PresetRecord(
1484 lilv_node_as_string(preset),
1485 lilv_node_as_string(name),
1487 comment ? lilv_node_as_string (comment) : ""
1489 lilv_node_free(name);
1491 warning << string_compose(
1492 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1493 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1494 lilv_node_as_string(preset)) << endmsg;
1497 lilv_node_free(comment);
1500 lilv_nodes_free(presets);
1502 lilv_node_free(rdfs_comment);
1503 lilv_node_free(rdfs_label);
1504 lilv_node_free(pset_Preset);
1505 lilv_node_free(lv2_appliesTo);
1509 set_port_value(const char* port_symbol,
1515 LV2Plugin* self = (LV2Plugin*)user_data;
1516 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1517 return; // TODO: Support non-float ports
1520 const uint32_t port_index = self->port_index(port_symbol);
1521 if (port_index != (uint32_t)-1) {
1522 self->set_parameter(port_index, *(const float*)value);
1523 self->PresetPortSetValue (port_index, *(const float*)value); /* EMIT SIGNAL */
1528 LV2Plugin::load_preset(PresetRecord r)
1530 LilvWorld* world = _world.world;
1531 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1532 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1534 const LV2_Feature* state_features[2] = { NULL, NULL };
1535 LV2_Worker_Schedule schedule = { _state_worker, work_schedule };
1536 const LV2_Feature state_sched_feature = { LV2_WORKER__schedule, &schedule };
1537 if (_state_worker) {
1538 state_features[0] = &state_sched_feature;
1542 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, state_features);
1543 lilv_state_free(state);
1544 Plugin::load_preset(r);
1547 lilv_node_free(pset);
1552 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1557 LV2Plugin *plugin = (LV2Plugin *) user_data;
1559 uint32_t index = plugin->port_index(port_symbol);
1560 if (index != (uint32_t) -1) {
1561 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1563 *size = sizeof(float);
1564 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1565 value = &plugin->_shadow_data[index];
1577 LV2Plugin::do_save_preset(string name)
1579 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1580 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1581 const string base_name = legalize_for_uri(name);
1582 const string file_name = base_name + ".ttl";
1583 #ifdef PLATFORM_WINDOWS
1584 /* http://lv2plug.in/pages/filesystem-hierarchy-standard.html */
1585 std::string appdata = PBD::get_win_special_folder_path (CSIDL_APPDATA);
1586 if (appdata.empty ()) {
1587 // TODO consider a fallback location
1590 const string bundle = Glib::build_filename (
1591 appdata, "LV2", prefix + "_" + base_name + ".lv2");
1593 /* while macOS/OSX user-specific path is
1595 * $HOME/Library/Audio/Plug-Ins/LV2/
1597 * liblilv's LV2 search path on all unices does include ~/.lv2/
1598 * Ardour has been saving lv2 presets to ~/.lv2 for along time,
1599 * so just keep them there.
1601 const string bundle = Glib::build_filename(
1602 Glib::get_home_dir(),
1603 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1606 #ifdef HAVE_LILV_0_21_3
1607 /* delete reference to old preset (if any) */
1608 const PresetRecord* r = preset_by_label(name);
1610 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1612 lilv_world_unload_resource (_world.world, pset);
1613 lilv_node_free(pset);
1618 LilvState* state = lilv_state_new_from_instance(
1621 _uri_map.urid_map(),
1622 scratch_dir().c_str(), // file_dir
1623 bundle.c_str(), // copy_dir
1624 bundle.c_str(), // link_dir
1625 bundle.c_str(), // save_dir
1626 lv2plugin_get_port_value, // get_value
1627 (void*)this, // user_data
1628 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1629 _features // features
1632 lilv_state_set_label(state, name.c_str());
1634 _world.world, // world
1635 _uri_map.urid_map(), // map
1636 _uri_map.urid_unmap(), // unmap
1638 NULL, // uri (NULL = use file URI)
1639 bundle.c_str(), // dir
1640 file_name.c_str() // filename
1643 lilv_state_free(state);
1645 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1646 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1647 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1648 #ifdef HAVE_LILV_0_21_3
1649 lilv_world_unload_resource(_world.world, node_preset);
1650 lilv_world_unload_bundle(_world.world, node_bundle);
1652 lilv_world_load_bundle(_world.world, node_bundle);
1653 lilv_world_load_resource(_world.world, node_preset);
1654 lilv_node_free(node_bundle);
1655 lilv_node_free(node_preset);
1656 lilv_node_free(plug_name);
1661 LV2Plugin::do_remove_preset(string name)
1663 #ifdef HAVE_LILV_0_21_3
1664 /* Look up preset record by label (FIXME: ick, label as ID) */
1665 const PresetRecord* r = preset_by_label(name);
1670 /* Load a LilvState for the preset. */
1671 LilvWorld* world = _world.world;
1672 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1673 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1675 lilv_node_free(pset);
1679 /* Unload preset from world. */
1680 lilv_world_unload_resource(world, pset);
1682 /* Delete it from the file system. This will remove the preset file and the entry
1683 from the manifest. If this results in an empty manifest (i.e. the
1684 preset is the only thing in the bundle), then the bundle is removed. */
1685 lilv_state_delete(world, state);
1687 lilv_state_free(state);
1688 lilv_node_free(pset);
1690 /* Without lilv_state_delete(), we could delete the preset file, but this
1691 would leave a broken bundle/manifest around, so the preset would still
1692 be visible, but broken. Naively deleting a bundle is too dangerous, so
1693 we simply do not support preset deletion with older Lilv */
1697 LV2Plugin::has_editor() const
1699 return _impl->ui != NULL;
1703 LV2Plugin::has_message_output() const
1705 for (uint32_t i = 0; i < num_ports(); ++i) {
1706 if ((_port_flags[i] & PORT_SEQUENCE) &&
1707 (_port_flags[i] & PORT_OUTPUT)) {
1715 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1719 const uint8_t* body)
1721 const uint32_t buf_size = sizeof(UIMessage) + size;
1722 vector<uint8_t> buf(buf_size);
1724 UIMessage* msg = (UIMessage*)&buf[0];
1726 msg->protocol = protocol;
1728 memcpy(msg + 1, body, size);
1730 return (dest->write(&buf[0], buf_size) == buf_size);
1734 LV2Plugin::write_from_ui(uint32_t index,
1737 const uint8_t* body)
1740 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1741 /* buffer data communication from plugin UI to plugin instance.
1742 * this buffer needs to potentially hold
1743 * (port's minimumSize) * (audio-periods) / (UI-periods)
1746 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1747 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1748 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1750 * it is NOT safe to overflow (msg.size will be misinterpreted)
1752 uint32_t bufsiz = 32768;
1753 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1754 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1756 int fact = ceilf(_session.sample_rate () / 3000.f);
1757 rbs = max((size_t) bufsiz * std::max (8, fact), rbs);
1758 _from_ui = new RingBuffer<uint8_t>(rbs);
1761 if (!write_to(_from_ui, index, protocol, size, body)) {
1762 error << "Error writing from UI to plugin" << endmsg;
1769 LV2Plugin::write_to_ui(uint32_t index,
1772 const uint8_t* body)
1774 if (!write_to(_to_ui, index, protocol, size, body)) {
1775 error << "Error writing from plugin to UI" << endmsg;
1782 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1784 switch (value.type()) {
1785 case Variant::NOTHING:
1787 case Variant::BEATS:
1788 // No atom type for this, just forge a double
1789 lv2_atom_forge_double(forge, value.get_beats().to_double());
1792 lv2_atom_forge_bool(forge, value.get_bool());
1794 case Variant::DOUBLE:
1795 lv2_atom_forge_double(forge, value.get_double());
1797 case Variant::FLOAT:
1798 lv2_atom_forge_float(forge, value.get_float());
1801 lv2_atom_forge_int(forge, value.get_int());
1804 lv2_atom_forge_long(forge, value.get_long());
1807 lv2_atom_forge_path(
1808 forge, value.get_path().c_str(), value.get_path().size());
1810 case Variant::STRING:
1811 lv2_atom_forge_string(
1812 forge, value.get_string().c_str(), value.get_string().size());
1816 forge, value.get_uri().c_str(), value.get_uri().size());
1821 /** Get a variant type from a URI, return false iff no match found. */
1823 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1825 if (uri == LV2_ATOM__Bool) {
1826 type = Variant::BOOL;
1827 } else if (uri == LV2_ATOM__Double) {
1828 type = Variant::DOUBLE;
1829 } else if (uri == LV2_ATOM__Float) {
1830 type = Variant::FLOAT;
1831 } else if (uri == LV2_ATOM__Int) {
1832 type = Variant::INT;
1833 } else if (uri == LV2_ATOM__Long) {
1834 type = Variant::LONG;
1835 } else if (uri == LV2_ATOM__Path) {
1836 type = Variant::PATH;
1837 } else if (uri == LV2_ATOM__String) {
1838 type = Variant::STRING;
1839 } else if (uri == LV2_ATOM__URI) {
1840 type = Variant::URI;
1848 LV2Plugin::set_property(uint32_t key, const Variant& value)
1850 if (_patch_port_in_index == (uint32_t)-1) {
1851 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1853 } else if (value.type() == Variant::NOTHING) {
1854 error << "LV2: set_property called with void value" << endmsg;
1858 // Set up forge to write to temporary buffer on the stack
1859 LV2_Atom_Forge* forge = &_impl->ui_forge;
1860 LV2_Atom_Forge_Frame sample;
1861 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1863 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1865 // Serialize patch:Set message to set property
1866 #ifdef HAVE_LV2_1_10_0
1867 lv2_atom_forge_object(forge, &sample, 0, _uri_map.urids.patch_Set);
1868 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1869 lv2_atom_forge_urid(forge, key);
1870 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1872 lv2_atom_forge_blank(forge, &sample, 0, _uri_map.urids.patch_Set);
1873 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1874 lv2_atom_forge_urid(forge, key);
1875 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1878 forge_variant(forge, value);
1880 // Write message to UI=>Plugin ring
1881 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1882 write_from_ui(_patch_port_in_index,
1883 _uri_map.urids.atom_eventTransfer,
1884 lv2_atom_total_size(atom),
1885 (const uint8_t*)atom);
1888 const ParameterDescriptor&
1889 LV2Plugin::get_property_descriptor(uint32_t id) const
1891 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1892 if (p != _property_descriptors.end()) {
1895 return Plugin::get_property_descriptor(id);
1899 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1901 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1902 desc.unit = ParameterDescriptor::MIDI_NOTE;
1903 } else if (lilv_nodes_contains(units, _world.units_db)) {
1904 desc.unit = ParameterDescriptor::DB;
1905 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1906 desc.unit = ParameterDescriptor::HZ;
1908 if (lilv_nodes_size(units) > 0) {
1909 const LilvNode* unit = lilv_nodes_get_first(units);
1910 LilvNode* render = get_value(lworld, unit, _world.units_render);
1912 desc.print_fmt = lilv_node_as_string(render);
1913 /* override lilv's default "%f" format */
1914 if (desc.integer_step) {
1915 replace_all (desc.print_fmt, "%f", "%.0f");
1916 } else if (desc.upper - desc.lower >= 1000) {
1917 replace_all (desc.print_fmt, "%f", "%.1f");
1918 } else if (desc.upper - desc.lower >= 100) {
1919 replace_all (desc.print_fmt, "%f", "%.2f");
1921 replace_all (desc.print_fmt, "%f", "%.3f");
1923 lilv_node_free(render);
1929 load_parameter_descriptor(LV2World& world,
1930 ParameterDescriptor& desc,
1931 Variant::Type datatype,
1932 const LilvNode* subject)
1934 LilvWorld* lworld = _world.world;
1935 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1936 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1937 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1938 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1939 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1941 desc.label = lilv_node_as_string(label);
1944 if (lilv_node_is_float(def)) {
1945 desc.normal = lilv_node_as_float(def);
1946 } else if (lilv_node_is_int(def)) {
1947 desc.normal = lilv_node_as_int(def);
1951 if (lilv_node_is_float(minimum)) {
1952 desc.lower = lilv_node_as_float(minimum);
1953 } else if (lilv_node_is_int(minimum)) {
1954 desc.lower = lilv_node_as_int(minimum);
1958 if (lilv_node_is_float(maximum)) {
1959 desc.upper = lilv_node_as_float(maximum);
1960 } else if (lilv_node_is_int(maximum)) {
1961 desc.upper = lilv_node_as_int(maximum);
1964 load_parameter_descriptor_units(lworld, desc, units);
1965 desc.datatype = datatype;
1966 desc.toggled |= datatype == Variant::BOOL;
1967 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1968 desc.update_steps();
1970 lilv_nodes_free(units);
1971 lilv_node_free(label);
1972 lilv_node_free(def);
1973 lilv_node_free(minimum);
1974 lilv_node_free(maximum);
1978 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1980 LilvWorld* lworld = _world.world;
1981 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1982 LilvNodes* properties = lilv_world_find_nodes(
1983 lworld, subject, _world.patch_writable, NULL);
1984 LILV_FOREACH(nodes, p, properties) {
1985 // Get label and range
1986 const LilvNode* prop = lilv_nodes_get(properties, p);
1987 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1989 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1990 lilv_node_as_uri(prop)) << endmsg;
1994 // Convert range to variant type (TODO: support for multiple range types)
1995 Variant::Type datatype;
1996 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1997 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1998 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
2002 // Add description to result
2003 ParameterDescriptor desc;
2004 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
2005 desc.datatype = datatype;
2006 load_parameter_descriptor(_world, desc, datatype, prop);
2007 descs.insert(std::make_pair(desc.key, desc));
2009 lilv_node_free(range);
2011 lilv_nodes_free(properties);
2015 LV2Plugin::get_property_value (uint32_t prop_id) const
2017 std::map<uint32_t, Variant>::const_iterator it;
2018 if ((it = _property_values.find (prop_id)) == _property_values.end()) {
2025 LV2Plugin::announce_property_values()
2027 if (_patch_port_in_index == (uint32_t)-1) {
2031 // Set up forge to write to temporary buffer on the stack
2032 LV2_Atom_Forge* forge = &_impl->ui_forge;
2033 LV2_Atom_Forge_Frame sample;
2034 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
2036 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
2038 // Serialize patch:Get message with no subject (implicitly plugin instance)
2039 #ifdef HAVE_LV2_1_10_0
2040 lv2_atom_forge_object(forge, &sample, 0, _uri_map.urids.patch_Get);
2042 lv2_atom_forge_blank(forge, &sample, 0, _uri_map.urids.patch_Get);
2045 // Write message to UI=>Plugin ring
2046 const LV2_Atom* const atom = (const LV2_Atom*)buf;
2047 write_from_ui(_patch_port_in_index,
2048 _uri_map.urids.atom_eventTransfer,
2049 lv2_atom_total_size(atom),
2050 (const uint8_t*)atom);
2054 LV2Plugin::enable_ui_emission()
2057 /* see note in LV2Plugin::write_from_ui() */
2058 uint32_t bufsiz = 32768;
2059 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
2060 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
2062 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
2063 rbs = max((size_t) bufsiz * 8, rbs);
2064 _to_ui = new RingBuffer<uint8_t>(rbs);
2069 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
2075 uint32_t read_space = _to_ui->read_space();
2076 while (read_space > sizeof(UIMessage)) {
2078 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2079 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
2082 vector<uint8_t> body(msg.size);
2083 if (_to_ui->read(&body[0], msg.size) != msg.size) {
2084 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
2088 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
2090 read_space -= sizeof(msg) + msg.size;
2095 LV2Plugin::work(Worker& worker, uint32_t size, const void* data)
2097 Glib::Threads::Mutex::Lock lm(_work_mutex);
2098 return _impl->work_iface->work(
2099 _impl->instance->lv2_handle, work_respond, &worker, size, data);
2103 LV2Plugin::work_response(uint32_t size, const void* data)
2105 return _impl->work_iface->work_response(
2106 _impl->instance->lv2_handle, size, data);
2110 LV2Plugin::set_insert_id(PBD::ID id)
2112 if (_insert_id == "0") {
2114 } else if (_insert_id != id) {
2115 lilv_state_free(_impl->state);
2116 _impl->state = NULL;
2122 LV2Plugin::set_state_dir (const std::string& d)
2124 _plugin_state_dir = d;
2128 LV2Plugin::set_state(const XMLNode& node, int version)
2131 XMLNodeConstIterator iter;
2135 if (node.name() != state_node_name()) {
2136 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
2140 #ifndef NO_PLUGIN_STATE
2142 if (version < 3000) {
2143 nodes = node.children("port");
2145 nodes = node.children("Port");
2148 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
2153 if (!child->get_property("symbol", sym)) {
2154 warning << _("LV2: port has no symbol, ignored") << endmsg;
2158 map<string, uint32_t>::iterator i = _port_indices.find(sym);
2162 if (i != _port_indices.end()) {
2163 port_id = i->second;
2165 warning << _("LV2: port has unknown index, ignored") << endmsg;
2170 if (!child->get_property("value", val)) {
2171 warning << _("LV2: port has no value, ignored") << endmsg;
2175 set_parameter(port_id, val);
2178 std::string template_dir;
2179 if (node.get_property("template-dir", template_dir)) {
2180 set_state_dir (template_dir);
2184 std::string state_dir;
2185 if (node.get_property("state-dir", state_dir) != 0) {
2186 if (sscanf(state_dir.c_str(), "state%u", &_state_version) != 1) {
2187 error << string_compose(
2188 "LV2: failed to parse state version from \"%1\"",
2189 state_dir) << endmsg;
2192 std::string state_file = Glib::build_filename(
2194 Glib::build_filename(state_dir, "state.ttl"));
2196 LilvState* state = lilv_state_new_from_file(
2197 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
2199 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
2200 lilv_state_free(_impl->state);
2201 _impl->state = state;
2204 if (!_plugin_state_dir.empty ()) {
2205 // force save with session, next time (increment counter)
2206 lilv_state_free (_impl->state);
2207 _impl->state = NULL;
2211 latency_compute_run();
2214 return Plugin::set_state(node, version);
2218 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
2220 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
2222 error << string_compose("LV2: get descriptor of non-existent port %1", which)
2227 LilvNodes* portunits;
2228 LilvNode *def, *min, *max;
2229 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
2230 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
2232 LilvNode* steps = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
2234 // TODO: Once we can rely on lilv 0.18.0 being present,
2235 // load_parameter_descriptor() can be used for ports as well
2236 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
2237 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
2238 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
2239 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
2240 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
2241 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
2242 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
2243 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
2244 load_parameter_descriptor_units(_world.world, desc, portunits);
2246 if (desc.sr_dependent) {
2247 desc.lower *= _session.sample_rate ();
2248 desc.upper *= _session.sample_rate ();
2251 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
2252 desc.scale_points = get_scale_points(which);
2255 desc.rangesteps = lilv_node_as_float (steps);
2258 desc.update_steps();
2260 lilv_node_free(def);
2261 lilv_node_free(min);
2262 lilv_node_free(max);
2263 lilv_node_free(steps);
2264 lilv_nodes_free(portunits);
2269 Plugin::IOPortDescription
2270 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2272 PortFlags match = 0;
2274 case DataType::AUDIO:
2277 case DataType::MIDI:
2278 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2281 return Plugin::IOPortDescription ("?");
2285 match |= PORT_INPUT;
2287 match |= PORT_OUTPUT;
2291 uint32_t idx = UINT32_MAX;
2293 uint32_t const num_ports = parameter_count();
2294 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2295 PortFlags flags = _port_flags[port_index];
2296 if ((flags & match) == match) {
2303 if (idx == UINT32_MAX) {
2304 return Plugin::IOPortDescription ("?");
2307 const LilvPort* pport = lilv_plugin_get_port_by_index (_impl->plugin, idx);
2309 LilvNode* name = lilv_port_get_name(_impl->plugin, pport);
2310 Plugin::IOPortDescription iod (lilv_node_as_string (name));
2311 lilv_node_free(name);
2313 /* get the port's pg:group */
2314 LilvNodes* groups = lilv_port_get_value (_impl->plugin, pport, _world.groups_group);
2315 if (lilv_nodes_size (groups) > 0) {
2316 const LilvNode* group = lilv_nodes_get_first (groups);
2317 LilvNodes* grouplabel = lilv_world_find_nodes (_world.world, group, _world.rdfs_label, NULL);
2319 /* get the name of the port-group */
2320 if (lilv_nodes_size (grouplabel) > 0) {
2321 const LilvNode* grpname = lilv_nodes_get_first (grouplabel);
2322 iod.group_name = lilv_node_as_string (grpname);
2324 lilv_nodes_free (grouplabel);
2326 /* get all port designations.
2327 * we're interested in e.g. lv2:designation pg:right */
2328 LilvNodes* designations = lilv_port_get_value (_impl->plugin, pport, _world.lv2_designation);
2329 if (lilv_nodes_size (designations) > 0) {
2330 /* get all pg:elements of the pg:group */
2331 LilvNodes* group_childs = lilv_world_find_nodes (_world.world, group, _world.groups_element, NULL);
2332 if (lilv_nodes_size (group_childs) > 0) {
2333 /* iterate over all port designations .. */
2334 LILV_FOREACH (nodes, i, designations) {
2335 const LilvNode* designation = lilv_nodes_get (designations, i);
2336 /* match the lv2:designation's element against the port-group's element */
2337 LILV_FOREACH (nodes, j, group_childs) {
2338 const LilvNode* group_element = lilv_nodes_get (group_childs, j);
2339 LilvNodes* elem = lilv_world_find_nodes (_world.world, group_element, _world.lv2_designation, designation);
2340 /* found it. Now look up the index (channel-number) of the pg:Element */
2341 if (lilv_nodes_size (elem) > 0) {
2342 LilvNodes* idx = lilv_world_find_nodes (_world.world, lilv_nodes_get_first (elem), _world.lv2_index, NULL);
2343 if (lilv_node_is_int (lilv_nodes_get_first (idx))) {
2344 iod.group_channel = lilv_node_as_int(lilv_nodes_get_first (idx));
2351 lilv_nodes_free (groups);
2352 lilv_nodes_free (designations);
2355 if (lilv_port_has_property(_impl->plugin, pport, _world.lv2_isSideChain)) {
2356 iod.is_sidechain = true;
2362 LV2Plugin::describe_parameter(Evoral::Parameter which)
2364 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2366 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which.id());
2368 if (lilv_port_has_property(_impl->plugin, port, _world.ext_notOnGUI)) {
2369 return X_("hidden");
2372 const LilvPort* fwport = lilv_plugin_get_port_by_designation(_impl->plugin, _world.lv2_InputPort, _world.lv2_freewheeling);
2373 if (fwport && fwport == port) {
2374 return X_("hidden");
2377 if (lilv_port_has_property(_impl->plugin, port, _world.lv2_freewheeling)) {
2378 return X_("hidden");
2381 if (lilv_port_has_property(_impl->plugin, port, _world.lv2_reportsLatency)) {
2382 return X_("latency");
2385 LilvNode* name = lilv_port_get_name(_impl->plugin,
2386 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2387 string ret(lilv_node_as_string(name));
2388 lilv_node_free(name);
2396 LV2Plugin::max_latency () const
2398 return _max_latency;
2402 LV2Plugin::signal_latency() const
2404 if (_latency_control_port) {
2405 return (samplecnt_t)floor(*_latency_control_port);
2411 set<Evoral::Parameter>
2412 LV2Plugin::automatable() const
2414 set<Evoral::Parameter> ret;
2416 for (uint32_t i = 0; i < parameter_count(); ++i) {
2417 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2418 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2422 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2423 p != _property_descriptors.end();
2425 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2431 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2433 if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2434 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2435 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2439 LV2Plugin::AutomationCtrlPtr
2440 LV2Plugin::get_automation_control (uint32_t i)
2442 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2443 return AutomationCtrlPtr ();
2445 return _ctrl_map[i];
2449 LV2Plugin::activate()
2451 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2453 if (!_was_activated) {
2454 lilv_instance_activate(_impl->instance);
2455 _was_activated = true;
2460 LV2Plugin::deactivate()
2462 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2464 if (_was_activated) {
2465 lilv_instance_deactivate(_impl->instance);
2466 _was_activated = false;
2471 LV2Plugin::cleanup()
2473 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2476 lilv_instance_free(_impl->instance);
2477 _impl->instance = NULL;
2481 LV2Plugin::allocate_atom_event_buffers()
2483 /* reserve local scratch buffers for ATOM event-queues */
2484 const LilvPlugin* p = _impl->plugin;
2486 /* count non-MIDI atom event-ports
2487 * TODO: nicely ask drobilla to make a lilv_ call for that
2489 int count_atom_out = 0;
2490 int count_atom_in = 0;
2491 int minimumSize = 32768; // TODO use a per-port minimum-size
2492 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2493 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2494 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2495 LilvNodes* buffer_types = lilv_port_get_value(
2496 p, port, _world.atom_bufferType);
2497 LilvNodes* atom_supports = lilv_port_get_value(
2498 p, port, _world.atom_supports);
2500 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2501 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2504 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2507 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2508 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2509 if (min_size && lilv_node_is_int(min_size)) {
2510 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2512 lilv_nodes_free(min_size_v);
2514 lilv_nodes_free(buffer_types);
2515 lilv_nodes_free(atom_supports);
2519 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2520 name(), count_atom_in, count_atom_out));
2522 const int total_atom_buffers = (count_atom_in + count_atom_out);
2523 if (_atom_ev_buffers || total_atom_buffers == 0) {
2527 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2528 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2529 for (int i = 0; i < total_atom_buffers; ++i ) {
2530 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2531 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2533 _atom_ev_buffers[total_atom_buffers] = 0;
2537 /** Write an ardour position/time/tempo/meter as an LV2 event.
2538 * @return true on success.
2541 write_position(LV2_Atom_Forge* forge,
2543 const TempoMetric& t,
2544 Timecode::BBT_Time& bbt,
2547 samplepos_t position,
2550 const URIMap::URIDs& urids = URIMap::instance().urids;
2552 uint8_t pos_buf[256];
2553 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2554 LV2_Atom_Forge_Frame sample;
2555 #ifdef HAVE_LV2_1_10_0
2556 lv2_atom_forge_object(forge, &sample, 0, urids.time_Position);
2557 lv2_atom_forge_key(forge, urids.time_sample);
2558 lv2_atom_forge_long(forge, position);
2559 lv2_atom_forge_key(forge, urids.time_speed);
2560 lv2_atom_forge_float(forge, speed);
2561 lv2_atom_forge_key(forge, urids.time_barBeat);
2562 lv2_atom_forge_float(forge, bbt.beats - 1 +
2563 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2564 lv2_atom_forge_key(forge, urids.time_bar);
2565 lv2_atom_forge_long(forge, bbt.bars - 1);
2566 lv2_atom_forge_key(forge, urids.time_beatUnit);
2567 lv2_atom_forge_int(forge, t.meter().note_divisor());
2568 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2569 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2570 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2571 lv2_atom_forge_float(forge, bpm);
2573 lv2_atom_forge_blank(forge, &sample, 1, urids.time_Position);
2574 lv2_atom_forge_property_head(forge, urids.time_sample, 0);
2575 lv2_atom_forge_long(forge, position);
2576 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2577 lv2_atom_forge_float(forge, speed);
2578 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2579 lv2_atom_forge_float(forge, bbt.beats - 1 +
2580 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2581 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2582 lv2_atom_forge_long(forge, bbt.bars - 1);
2583 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2584 lv2_atom_forge_int(forge, t.meter().note_divisor());
2585 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2586 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2587 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2588 lv2_atom_forge_float(forge, bpm);
2591 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2592 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2593 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2594 (const uint8_t*)(atom + 1));
2598 LV2Plugin::connect_and_run(BufferSet& bufs,
2599 samplepos_t start, samplepos_t end, double speed,
2600 ChanMapping const& in_map, ChanMapping const& out_map,
2601 pframes_t nframes, samplecnt_t offset)
2603 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2604 Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2606 cycles_t then = get_cycles();
2608 TempoMap& tmap = _session.tempo_map();
2609 Metrics::const_iterator metric_i = tmap.metrics_end();
2610 TempoMetric tmetric = tmap.metric_at(start, &metric_i);
2612 if (_freewheel_control_port) {
2613 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2616 if (_bpm_control_port) {
2617 *_bpm_control_port = tmap.tempo_at_sample (start).note_types_per_minute();
2621 if (_can_write_automation && start != _next_cycle_start) {
2622 // add guard-points after locating
2623 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2624 i->second->guard = true;
2629 ChanCount bufs_count;
2630 bufs_count.set(DataType::AUDIO, 1);
2631 bufs_count.set(DataType::MIDI, 1);
2632 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2633 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2634 uint32_t const num_ports = parameter_count();
2635 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2637 uint32_t audio_in_index = 0;
2638 uint32_t audio_out_index = 0;
2639 uint32_t midi_in_index = 0;
2640 uint32_t midi_out_index = 0;
2641 uint32_t atom_port_index = 0;
2642 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2644 uint32_t index = nil_index;
2645 PortFlags flags = _port_flags[port_index];
2647 if (flags & PORT_AUDIO) {
2648 if (flags & PORT_INPUT) {
2649 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2651 ? bufs.get_audio(index).data(offset)
2652 : silent_bufs.get_audio(0).data(offset);
2654 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2656 ? bufs.get_audio(index).data(offset)
2657 : scratch_bufs.get_audio(0).data(offset);
2659 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2660 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2661 be necessary, but the mapping is illegal in some cases. Ideally
2662 that should be fixed, but this is easier...
2664 if (flags & PORT_MIDI) {
2665 if (flags & PORT_INPUT) {
2666 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2668 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2670 if (valid && bufs.count().n_midi() > index) {
2671 /* Note, ensure_lv2_bufsize() is not RT safe!
2672 * However free()/alloc() is only called if a
2673 * plugin requires a rsz:minimumSize buffersize
2674 * and the existing buffer if smaller.
2676 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2677 _ev_buffers[port_index] = bufs.get_lv2_midi(
2678 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2680 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2681 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2682 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2686 if (valid && (flags & PORT_INPUT)) {
2687 if ((flags & PORT_POSITION)) {
2688 Timecode::BBT_Time bbt (tmap.bbt_at_sample (start));
2689 double bpm = tmap.tempo_at_sample (start).note_types_per_minute();
2690 double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
2692 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2693 beatpos *= tmetric.meter().note_divisor() / 4.0;
2694 if (start != _next_cycle_start ||
2695 speed != _next_cycle_speed ||
2696 rint (1000 * beatpos) != rint(1000 * _next_cycle_beat) ||
2697 bpm != _current_bpm) {
2698 // Transport or Tempo has changed, write position at cycle start
2699 write_position(&_impl->forge, _ev_buffers[port_index],
2700 tmetric, bbt, speed, bpm, start, 0);
2704 // Get MIDI iterator range (empty range if no MIDI)
2705 MidiBuffer::iterator m = (index != nil_index)
2706 ? bufs.get_midi(index).begin()
2707 : silent_bufs.get_midi(0).end();
2708 MidiBuffer::iterator m_end = (index != nil_index)
2709 ? bufs.get_midi(index).end()
2712 // Now merge MIDI and any transport events into the buffer
2713 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2714 const samplepos_t tend = end;
2716 while (m != m_end || (metric_i != tmap.metrics_end() &&
2717 (*metric_i)->sample() < tend)) {
2718 MetricSection* metric = (metric_i != tmap.metrics_end())
2720 if (m != m_end && (!metric || metric->sample() > (*m).time())) {
2721 const Evoral::Event<samplepos_t> ev(*m, false);
2722 if (ev.time() < nframes) {
2723 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2724 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2728 tmetric.set_metric(metric);
2729 Timecode::BBT_Time bbt;
2730 bbt = tmap.bbt_at_sample (metric->sample());
2731 double bpm = tmap.tempo_at_sample (start/*XXX*/).note_types_per_minute();
2732 write_position(&_impl->forge, _ev_buffers[port_index],
2733 tmetric, bbt, speed, bpm,
2735 metric->sample() - start);
2739 } else if (!valid) {
2740 // Nothing we understand or care about, connect to scratch
2741 // see note for midi-buffer size above
2742 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2743 0, _port_minimumSize[port_index]);
2744 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2745 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2748 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2750 continue; // Control port, leave buffer alone
2752 lilv_instance_connect_port(_impl->instance, port_index, buf);
2755 // Read messages from UI and push into appropriate buffers
2757 uint32_t read_space = _from_ui->read_space();
2758 while (read_space > sizeof(UIMessage)) {
2760 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2761 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2764 vector<uint8_t> body(msg.size);
2765 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2766 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2769 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2770 LV2_Evbuf* buf = _ev_buffers[msg.index];
2771 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2772 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2773 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2774 (const uint8_t*)(atom + 1))) {
2775 error << "Failed to write data to LV2 event buffer\n";
2778 error << "Received unknown message type from UI" << endmsg;
2780 read_space -= sizeof(UIMessage) + msg.size;
2787 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2788 PortFlags flags = _port_flags[port_index];
2791 /* TODO ask drobilla about comment
2792 * "Make Ardour event buffers generic so plugins can communicate"
2793 * in libs/ardour/buffer_set.cc:310
2795 * ideally the user could choose which of the following two modes
2796 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2798 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2799 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2800 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2801 * for quite a while at least ;)
2803 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2804 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2805 const uint32_t buf_index = out_map.get(
2806 DataType::MIDI, midi_out_index++, &valid);
2808 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2811 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2812 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2813 const uint32_t buf_index = out_map.get(
2814 DataType::MIDI, midi_out_index++, &valid);
2816 bufs.flush_lv2_midi(true, buf_index);
2820 // Write messages to UI
2821 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2822 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2823 LV2_Evbuf* buf = _ev_buffers[port_index];
2824 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2825 lv2_evbuf_is_valid(i);
2826 i = lv2_evbuf_next(i)) {
2827 uint32_t samples, subframes, type, size;
2829 lv2_evbuf_get(i, &samples, &subframes, &type, &size, &data);
2832 // Intercept Automation Write Events
2833 if ((flags & PORT_AUTOCTRL)) {
2834 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2835 if (atom->type == _uri_map.urids.atom_Blank ||
2836 atom->type == _uri_map.urids.atom_Object) {
2837 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2838 if (obj->body.otype == _uri_map.urids.auto_event) {
2839 // only if transport_rolling ??
2840 const LV2_Atom* parameter = NULL;
2841 const LV2_Atom* value = NULL;
2842 lv2_atom_object_get(obj,
2843 _uri_map.urids.auto_parameter, ¶meter,
2844 _uri_map.urids.auto_value, &value,
2846 if (parameter && value) {
2847 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2848 const float v = ((const LV2_Atom_Float*)value)->body;
2849 // -> add automation event..
2850 DEBUG_TRACE(DEBUG::LV2Automate,
2851 string_compose ("Event p: %1 t: %2 v: %3\n", p, samples, v));
2852 AutomationCtrlPtr c = get_automation_control (p);
2854 (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2856 samplepos_t when = std::max ((samplepos_t) 0, start + samples - _current_latency);
2857 assert (start + samples - _current_latency >= 0);
2860 c->ac->list()->add (when, v, true, true);
2862 c->ac->set_double (v, when, true);
2867 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2868 // TODO optional arguments, for now we assume the plugin
2869 // writes automation for its own inputs
2870 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2871 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2872 if (_port_flags[i->first] & PORT_CTRLED) {
2873 DEBUG_TRACE(DEBUG::LV2Automate,
2874 string_compose ("Setup p: %1\n", i->first));
2875 i->second->ac->set_automation_state (Touch);
2879 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2880 // set [touched] parameters to "play" ??
2881 // allow plugin to change its mode (from analyze to apply)
2882 const LV2_Atom* parameter = NULL;
2883 const LV2_Atom* value = NULL;
2884 lv2_atom_object_get(obj,
2885 _uri_map.urids.auto_parameter, ¶meter,
2886 _uri_map.urids.auto_value, &value,
2888 if (parameter && value) {
2889 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2890 const float v = ((const LV2_Atom_Float*)value)->body;
2891 AutomationCtrlPtr c = get_automation_control (p);
2892 DEBUG_TRACE(DEBUG::LV2Automate,
2893 string_compose ("Finalize p: %1 v: %2\n", p, v));
2894 if (c && _port_flags[p] & PORT_CTRLER) {
2895 c->ac->set_value(v, Controllable::NoGroup);
2898 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2900 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2901 // guard will be false if an event was written
2902 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2903 DEBUG_TRACE(DEBUG::LV2Automate,
2904 string_compose ("Thin p: %1\n", i->first));
2905 i->second->ac->alist ()->thin (20);
2909 else if (obj->body.otype == _uri_map.urids.auto_start) {
2910 const LV2_Atom* parameter = NULL;
2911 lv2_atom_object_get(obj,
2912 _uri_map.urids.auto_parameter, ¶meter,
2915 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2916 AutomationCtrlPtr c = get_automation_control (p);
2917 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2919 c->ac->start_touch (std::max ((samplepos_t)0, start - _current_latency));
2924 else if (obj->body.otype == _uri_map.urids.auto_end) {
2925 const LV2_Atom* parameter = NULL;
2926 lv2_atom_object_get(obj,
2927 _uri_map.urids.auto_parameter, ¶meter,
2930 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2931 AutomationCtrlPtr c = get_automation_control (p);
2932 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2934 c->ac->stop_touch (std::max ((samplepos_t)0, start - _current_latency));
2941 // Intercept state dirty message
2942 if (_has_state_interface /* && (flags & PORT_DIRTYMSG)*/) {
2943 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2944 if (atom->type == _uri_map.urids.atom_Blank ||
2945 atom->type == _uri_map.urids.atom_Object) {
2946 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2947 if (obj->body.otype == _uri_map.urids.state_StateChanged) {
2948 _session.set_dirty ();
2953 // Intercept patch change messages to emit PropertyChanged signal
2954 if ((flags & PORT_PATCHMSG)) {
2955 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2956 if (atom->type == _uri_map.urids.atom_Blank ||
2957 atom->type == _uri_map.urids.atom_Object) {
2958 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2959 if (obj->body.otype == _uri_map.urids.patch_Set) {
2960 const LV2_Atom* property = NULL;
2961 const LV2_Atom* value = NULL;
2962 lv2_atom_object_get(obj,
2963 _uri_map.urids.patch_property, &property,
2964 _uri_map.urids.patch_value, &value,
2967 if (property && value &&
2968 property->type == _uri_map.urids.atom_URID &&
2969 value->type == _uri_map.urids.atom_Path) {
2970 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2971 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2973 // Emit PropertyChanged signal for UI
2974 // TODO: This should emit the control's Changed signal
2975 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2976 _property_values[prop_id] = Variant(Variant::PATH, path);
2978 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2984 if (!_to_ui) continue;
2985 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2986 size + sizeof(LV2_Atom),
2987 data - sizeof(LV2_Atom));
2992 cycles_t now = get_cycles();
2993 set_cycles((uint32_t)(now - then));
2995 // Update expected transport information for next cycle so we can detect changes
2996 _next_cycle_speed = speed;
2997 _next_cycle_start = end;
3000 /* keep track of lv2:timePosition like plugins can do.
3001 * Note: for no-midi plugins, we only ever send information at cycle-start,
3002 * so it needs to be realative to that.
3004 TempoMetric t = tmap.metric_at(start);
3005 _current_bpm = tmap.tempo_at_sample (start).note_types_per_minute();
3006 Timecode::BBT_Time bbt (tmap.bbt_at_sample (start));
3007 double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
3009 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
3010 beatpos *= tmetric.meter().note_divisor() / 4.0;
3011 _next_cycle_beat = beatpos + nframes * speed * _current_bpm / (60.f * _session.sample_rate());
3014 if (_latency_control_port) {
3015 samplecnt_t new_latency = signal_latency ();
3016 _current_latency = new_latency;
3022 LV2Plugin::parameter_is_control(uint32_t param) const
3024 assert(param < _port_flags.size());
3025 return _port_flags[param] & PORT_CONTROL;
3029 LV2Plugin::parameter_is_audio(uint32_t param) const
3031 assert(param < _port_flags.size());
3032 return _port_flags[param] & PORT_AUDIO;
3036 LV2Plugin::parameter_is_event(uint32_t param) const
3038 assert(param < _port_flags.size());
3039 return _port_flags[param] & PORT_EVENT;
3043 LV2Plugin::parameter_is_output(uint32_t param) const
3045 assert(param < _port_flags.size());
3046 return _port_flags[param] & PORT_OUTPUT;
3050 LV2Plugin::parameter_is_input(uint32_t param) const
3052 assert(param < _port_flags.size());
3053 return _port_flags[param] & PORT_INPUT;
3057 LV2Plugin::designated_bypass_port ()
3059 const LilvPort* port = NULL;
3060 LilvNode* designation = lilv_new_uri (_world.world, LV2_CORE_PREFIX "enabled");
3061 port = lilv_plugin_get_port_by_designation (
3062 _impl->plugin, _world.lv2_InputPort, designation);
3063 lilv_node_free(designation);
3065 return lilv_port_get_index (_impl->plugin, port);
3068 /* deprecated on 2016-Sep-18 in favor of lv2:enabled */
3069 designation = lilv_new_uri (_world.world, LV2_PROCESSING_URI__enable);
3070 port = lilv_plugin_get_port_by_designation (
3071 _impl->plugin, _world.lv2_InputPort, designation);
3072 lilv_node_free(designation);
3074 return lilv_port_get_index (_impl->plugin, port);
3081 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
3084 if (param < parameter_count()) {
3085 snprintf(buf, len, "%.3f", get_parameter(param));
3092 boost::shared_ptr<ScalePoints>
3093 LV2Plugin::get_scale_points(uint32_t port_index) const
3095 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
3096 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
3098 boost::shared_ptr<ScalePoints> ret;
3103 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
3105 LILV_FOREACH(scale_points, i, points) {
3106 const LilvScalePoint* p = lilv_scale_points_get(points, i);
3107 const LilvNode* label = lilv_scale_point_get_label(p);
3108 const LilvNode* value = lilv_scale_point_get_value(p);
3109 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
3110 ret->insert(make_pair(lilv_node_as_string(label),
3111 lilv_node_as_float(value)));
3115 lilv_scale_points_free(points);
3120 LV2Plugin::run(pframes_t nframes, bool sync_work)
3122 uint32_t const N = parameter_count();
3123 for (uint32_t i = 0; i < N; ++i) {
3124 if (parameter_is_control(i) && parameter_is_input(i)) {
3125 _control_data[i] = _shadow_data[i];
3130 // Execute work synchronously if we're freewheeling (export)
3131 _worker->set_synchronous(sync_work || session().engine().freewheeling());
3134 // Run the plugin for this cycle
3135 lilv_instance_run(_impl->instance, nframes);
3137 // Emit any queued worker responses (calls a plugin callback)
3138 if (_state_worker) {
3139 _state_worker->emit_responses();
3142 _worker->emit_responses();
3145 // Notify the plugin that a work run cycle is complete
3146 if (_impl->work_iface) {
3147 if (_impl->work_iface->end_run) {
3148 _impl->work_iface->end_run(_impl->instance->lv2_handle);
3154 LV2Plugin::latency_compute_run()
3156 if (!_latency_control_port) {
3160 // Run the plugin so that it can set its latency parameter
3162 bool was_activated = _was_activated;
3165 uint32_t port_index = 0;
3166 uint32_t in_index = 0;
3167 uint32_t out_index = 0;
3169 // this is done in the main thread. non realtime.
3170 const samplecnt_t bufsize = _engine.samples_per_cycle();
3171 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
3173 memset(buffer, 0, sizeof(float) * bufsize);
3175 // FIXME: Ensure plugins can handle in-place processing
3179 while (port_index < parameter_count()) {
3180 if (parameter_is_audio(port_index)) {
3181 if (parameter_is_input(port_index)) {
3182 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3184 } else if (parameter_is_output(port_index)) {
3185 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3194 if (was_activated) {
3201 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
3203 const LilvPort* port = NULL;
3204 LilvNode* designation = lilv_new_uri(_world.world, uri);
3205 port = lilv_plugin_get_port_by_designation(
3206 plugin, _world.lv2_InputPort, designation);
3207 lilv_node_free(designation);
3209 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
3214 static bool lv2_filter (const string& str, void* /*arg*/)
3216 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
3218 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
3222 LV2World::LV2World()
3223 : world(lilv_world_new())
3224 , _bundle_checked(false)
3226 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
3227 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
3228 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
3229 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
3230 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
3231 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
3232 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
3233 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
3234 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
3235 ext_expensive = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
3236 ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
3237 ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
3238 ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
3239 groups_group = lilv_new_uri(world, LV2_PORT_GROUPS__group);
3240 groups_element = lilv_new_uri(world, LV2_PORT_GROUPS__element);
3241 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
3242 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
3243 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
3244 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
3245 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
3246 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
3247 lv2_index = lilv_new_uri(world, LV2_CORE__index);
3248 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
3249 lv2_default = lilv_new_uri(world, LV2_CORE__default);
3250 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
3251 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
3252 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
3253 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
3254 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
3255 lv2_designation = lilv_new_uri(world, LV2_CORE__designation);
3256 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
3257 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
3258 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
3259 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
3260 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
3261 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
3262 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
3263 time_Position = lilv_new_uri(world, LV2_TIME__Position);
3264 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
3265 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
3266 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
3267 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
3268 units_render = lilv_new_uri(world, LV2_UNITS__render);
3269 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
3270 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
3271 units_db = lilv_new_uri(world, LV2_UNITS__db);
3272 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
3273 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
3275 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls"); // deprecated 2016-09-18
3276 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
3277 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
3278 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
3279 auto_automation_controller = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
3280 inline_display_in_gui = lilv_new_uri(world, LV2_INLINEDISPLAY__in_gui);
3282 #ifdef HAVE_LV2_1_2_0
3283 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
3284 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
3285 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
3286 bufz_coarseBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#coarseBlockLength");
3291 LV2World::~LV2World()
3296 #ifdef HAVE_LV2_1_2_0
3297 lilv_node_free(bufz_coarseBlockLength);
3298 lilv_node_free(bufz_nominalBlockLength);
3299 lilv_node_free(bufz_fixedBlockLength);
3300 lilv_node_free(bufz_powerOf2BlockLength);
3303 lilv_node_free(lv2_noSampleAccurateCtrl);
3304 lilv_node_free(auto_can_write_automatation);
3305 lilv_node_free(auto_automation_control);
3306 lilv_node_free(auto_automation_controlled);
3307 lilv_node_free(auto_automation_controller);
3309 lilv_node_free(patch_Message);
3310 lilv_node_free(patch_writable);
3311 lilv_node_free(units_hz);
3312 lilv_node_free(units_midiNote);
3313 lilv_node_free(units_db);
3314 lilv_node_free(units_unit);
3315 lilv_node_free(units_render);
3316 lilv_node_free(ui_externalkx);
3317 lilv_node_free(ui_external);
3318 lilv_node_free(ui_GtkUI);
3319 lilv_node_free(time_Position);
3320 lilv_node_free(rsz_minimumSize);
3321 lilv_node_free(rdfs_comment);
3322 lilv_node_free(rdfs_label);
3323 lilv_node_free(rdfs_range);
3324 lilv_node_free(midi_MidiEvent);
3325 lilv_node_free(lv2_designation);
3326 lilv_node_free(lv2_enumeration);
3327 lilv_node_free(lv2_freewheeling);
3328 lilv_node_free(lv2_toggled);
3329 lilv_node_free(lv2_sampleRate);
3330 lilv_node_free(lv2_reportsLatency);
3331 lilv_node_free(lv2_index);
3332 lilv_node_free(lv2_integer);
3333 lilv_node_free(lv2_isSideChain);
3334 lilv_node_free(lv2_inPlaceBroken);
3335 lilv_node_free(lv2_OutputPort);
3336 lilv_node_free(lv2_InputPort);
3337 lilv_node_free(lv2_ControlPort);
3338 lilv_node_free(lv2_AudioPort);
3339 lilv_node_free(groups_group);
3340 lilv_node_free(groups_element);
3341 lilv_node_free(ext_rangeSteps);
3342 lilv_node_free(ext_notAutomatic);
3343 lilv_node_free(ext_causesArtifacts);
3344 lilv_node_free(ext_expensive);
3345 lilv_node_free(ext_notOnGUI);
3346 lilv_node_free(ext_logarithmic);
3347 lilv_node_free(ev_EventPort);
3348 lilv_node_free(atom_supports);
3349 lilv_node_free(atom_eventTransfer);
3350 lilv_node_free(atom_bufferType);
3351 lilv_node_free(atom_Sequence);
3352 lilv_node_free(atom_Chunk);
3353 lilv_node_free(atom_AtomPort);
3354 lilv_world_free(world);
3359 LV2World::load_bundled_plugins(bool verbose)
3361 if (!_bundle_checked) {
3363 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
3366 vector<string> plugin_objects;
3367 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
3368 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
3369 #ifdef PLATFORM_WINDOWS
3370 string uri = "file:///" + *x + "/";
3372 string uri = "file://" + *x + "/";
3374 LilvNode *node = lilv_new_uri(world, uri.c_str());
3375 lilv_world_load_bundle(world, node);
3376 lilv_node_free(node);
3379 lilv_world_load_all(world);
3380 _bundle_checked = true;
3384 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
3387 _plugin_uri = strdup(plugin_uri);
3390 LV2PluginInfo::~LV2PluginInfo()
3397 LV2PluginInfo::load(Session& session)
3401 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3402 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3403 if (!uri) { throw failed_constructor(); }
3404 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3405 if (!lp) { throw failed_constructor(); }
3406 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.sample_rate()));
3407 lilv_node_free(uri);
3408 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3410 } catch (failed_constructor& err) {
3411 return PluginPtr((Plugin*)0);
3417 std::vector<Plugin::PresetRecord>
3418 LV2PluginInfo::get_presets (bool /*user_only*/) const
3420 std::vector<Plugin::PresetRecord> p;
3421 #ifndef NO_PLUGIN_STATE
3422 const LilvPlugin* lp = NULL;
3425 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3426 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3427 if (!uri) { throw failed_constructor(); }
3428 lp = lilv_plugins_get_by_uri(plugins, uri);
3429 if (!lp) { throw failed_constructor(); }
3430 lilv_node_free(uri);
3431 } catch (failed_constructor& err) {
3435 // see LV2Plugin::find_presets
3436 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3437 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3438 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3439 LilvNode* rdfs_comment = lilv_new_uri(_world.world, LILV_NS_RDFS "comment");
3441 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3442 LILV_FOREACH(nodes, i, presets) {
3443 const LilvNode* preset = lilv_nodes_get(presets, i);
3444 lilv_world_load_resource(_world.world, preset);
3445 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3446 LilvNode* comment = get_value(_world.world, preset, rdfs_comment);
3447 /* TODO properly identify user vs factory presets.
3448 * here's an indirect condition: only factory presets can have comments
3450 bool userpreset = comment ? false : true;
3452 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset, comment ? lilv_node_as_string (comment) : ""));
3453 lilv_node_free(name);
3456 lilv_node_free(comment);
3459 lilv_nodes_free(presets);
3460 lilv_node_free(rdfs_comment);
3461 lilv_node_free(rdfs_label);
3462 lilv_node_free(pset_Preset);
3463 lilv_node_free(lv2_appliesTo);
3469 LV2PluginInfo::discover()
3472 world.load_bundled_plugins();
3473 _world.load_bundled_plugins(true);
3475 PluginInfoList* plugs = new PluginInfoList;
3476 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3478 LILV_FOREACH(plugins, i, plugins) {
3479 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3480 const LilvNode* pun = lilv_plugin_get_uri(p);
3482 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3484 LilvNode* name = lilv_plugin_get_name(p);
3485 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3486 warning << "Ignoring invalid LV2 plugin "
3487 << lilv_node_as_string(lilv_plugin_get_uri(p))
3492 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3493 warning << string_compose(
3494 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3495 lilv_node_as_string(name)) << endmsg;
3496 lilv_node_free(name);
3500 #ifdef HAVE_LV2_1_2_0
3501 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3502 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3503 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3505 warning << string_compose(
3506 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3507 lilv_node_as_string(name)) << endmsg;
3508 lilv_nodes_free(required_features);
3509 lilv_node_free(name);
3512 lilv_nodes_free(required_features);
3517 info->name = string(lilv_node_as_string(name));
3518 lilv_node_free(name);
3519 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3521 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3522 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3523 info->category = lilv_node_as_string(label);
3525 LilvNode* author_name = lilv_plugin_get_author_name(p);
3526 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3527 lilv_node_free(author_name);
3529 info->path = "/NOPATH"; // Meaningless for LV2
3531 /* count atom-event-ports that feature
3532 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3534 * TODO: nicely ask drobilla to make a lilv_ call for that
3536 int count_midi_out = 0;
3537 int count_midi_in = 0;
3538 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3539 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3540 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3541 LilvNodes* buffer_types = lilv_port_get_value(
3542 p, port, world.atom_bufferType);
3543 LilvNodes* atom_supports = lilv_port_get_value(
3544 p, port, world.atom_supports);
3546 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3547 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3548 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3551 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3555 lilv_nodes_free(buffer_types);
3556 lilv_nodes_free(atom_supports);
3560 info->n_inputs.set_audio(
3561 lilv_plugin_get_num_ports_of_class(
3562 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3563 info->n_inputs.set_midi(
3564 lilv_plugin_get_num_ports_of_class(
3565 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3568 info->n_outputs.set_audio(
3569 lilv_plugin_get_num_ports_of_class(
3570 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3571 info->n_outputs.set_midi(
3572 lilv_plugin_get_num_ports_of_class(
3573 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3576 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3577 info->index = 0; // Meaningless for LV2
3579 plugs->push_back(info);