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/replace_all.h"
41 #include "pbd/xml++.h"
43 #include "libardour-config.h"
45 #include "ardour/audio_buffer.h"
46 #include "ardour/audioengine.h"
47 #include "ardour/debug.h"
48 #include "ardour/lv2_plugin.h"
49 #include "ardour/midi_patch_manager.h"
50 #include "ardour/session.h"
51 #include "ardour/tempo.h"
52 #include "ardour/types.h"
53 #include "ardour/utils.h"
54 #include "ardour/worker.h"
55 #include "ardour/search_paths.h"
60 #include <lilv/lilv.h>
62 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
63 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
64 #include "lv2/lv2plug.in/ns/ext/log/log.h"
65 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
66 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
67 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
68 #include "lv2/lv2plug.in/ns/ext/state/state.h"
69 #include "lv2/lv2plug.in/ns/ext/time/time.h"
70 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
71 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
72 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
73 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
74 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
75 #include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
77 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
78 #include "lv2/lv2plug.in/ns/ext/options/options.h"
81 #include "lv2_evbuf.h"
84 #include <suil/suil.h>
87 // Compatibility for old LV2
88 #ifndef LV2_ATOM_CONTENTS_CONST
89 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
90 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
92 #ifndef LV2_ATOM_BODY_CONST
93 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
95 #ifndef LV2_PATCH__property
96 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
98 #ifndef LV2_PATCH__value
99 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
101 #ifndef LV2_PATCH__writable
102 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
105 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
106 This needs to be roughly the number of cycles the UI will get around to
107 actually processing the traffic. Lower values are flakier but save memory.
109 static const size_t NBUFS = 4;
112 using namespace ARDOUR;
115 bool LV2Plugin::force_state_save = false;
117 class LV2World : boost::noncopyable {
122 void load_bundled_plugins(bool verbose=false);
126 LilvNode* atom_AtomPort;
127 LilvNode* atom_Chunk;
128 LilvNode* atom_Sequence;
129 LilvNode* atom_bufferType;
130 LilvNode* atom_eventTransfer;
131 LilvNode* atom_supports;
132 LilvNode* ev_EventPort;
133 LilvNode* ext_logarithmic;
134 LilvNode* ext_notOnGUI;
135 LilvNode* ext_expensive;
136 LilvNode* ext_causesArtifacts;
137 LilvNode* ext_notAutomatic;
138 LilvNode* ext_rangeSteps;
139 LilvNode* groups_group;
140 LilvNode* groups_element;
141 LilvNode* lv2_AudioPort;
142 LilvNode* lv2_ControlPort;
143 LilvNode* lv2_InputPort;
144 LilvNode* lv2_OutputPort;
145 LilvNode* lv2_designation;
146 LilvNode* lv2_enumeration;
147 LilvNode* lv2_freewheeling;
148 LilvNode* lv2_inPlaceBroken;
149 LilvNode* lv2_isSideChain;
151 LilvNode* lv2_integer;
152 LilvNode* lv2_default;
153 LilvNode* lv2_minimum;
154 LilvNode* lv2_maximum;
155 LilvNode* lv2_reportsLatency;
156 LilvNode* lv2_sampleRate;
157 LilvNode* lv2_toggled;
158 LilvNode* midi_MidiEvent;
159 LilvNode* rdfs_comment;
160 LilvNode* rdfs_label;
161 LilvNode* rdfs_range;
162 LilvNode* rsz_minimumSize;
163 LilvNode* time_Position;
165 LilvNode* ui_external;
166 LilvNode* ui_externalkx;
169 LilvNode* units_unit;
170 LilvNode* units_render;
171 LilvNode* units_midiNote;
172 LilvNode* patch_writable;
173 LilvNode* patch_Message;
174 #ifdef HAVE_LV2_1_2_0
175 LilvNode* bufz_powerOf2BlockLength;
176 LilvNode* bufz_fixedBlockLength;
177 LilvNode* bufz_nominalBlockLength;
178 LilvNode* bufz_coarseBlockLength;
181 #ifdef HAVE_LV2_1_10_0
183 LilvNode* atom_float;
184 LilvNode* atom_object; // new in 1.8
185 LilvNode* atom_vector;
188 LilvNode* lv2_noSampleAccurateCtrl;
189 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
190 LilvNode* auto_automation_control; // atom:supports
191 LilvNode* auto_automation_controlled; // lv2:portProperty
192 LilvNode* auto_automation_controller; // lv2:portProperty
196 bool _bundle_checked;
199 static LV2World _world;
201 /* worker extension */
203 /** Called by the plugin to schedule non-RT work. */
204 static LV2_Worker_Status
205 work_schedule(LV2_Worker_Schedule_Handle handle,
209 return (((Worker*)handle)->schedule(size, data)
211 : LV2_WORKER_ERR_UNKNOWN);
214 /** Called by the plugin to respond to non-RT work. */
215 static LV2_Worker_Status
216 work_respond(LV2_Worker_Respond_Handle handle,
220 return (((Worker*)handle)->respond(size, data)
222 : LV2_WORKER_ERR_UNKNOWN);
226 /* inline display extension */
228 queue_draw (LV2_Inline_Display_Handle handle)
230 LV2Plugin* plugin = (LV2Plugin*)handle;
231 plugin->QueueDraw(); /* EMIT SIGNAL */
235 midnam_update (LV2_Midnam_Handle handle)
237 LV2Plugin* plugin = (LV2Plugin*)handle;
238 plugin->UpdateMidnam (); /* EMIT SIGNAL */
245 log_vprintf(LV2_Log_Handle /*handle*/,
251 const int ret = g_vasprintf(&str, fmt, args);
252 /* strip trailing whitespace */
253 while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
254 str[strlen (str) - 1] = '\0';
256 if (strlen (str) == 0) {
260 if (type == URIMap::instance().urids.log_Error) {
261 error << str << endmsg;
262 } else if (type == URIMap::instance().urids.log_Warning) {
263 warning << str << endmsg;
264 } else if (type == URIMap::instance().urids.log_Note) {
265 info << str << endmsg;
266 } else if (type == URIMap::instance().urids.log_Trace) {
267 DEBUG_TRACE(DEBUG::LV2, str);
273 log_printf(LV2_Log_Handle handle,
275 const char* fmt, ...)
279 const int ret = log_vprintf(handle, type, fmt, args);
284 struct LV2Plugin::Impl {
285 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
287 #ifdef HAVE_LV2_1_2_0
292 #ifdef HAVE_LV2_1_2_0
301 /** Find the LV2 input port with the given designation.
302 * If found, bufptrs[port_index] will be set to bufptr.
304 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
306 const LilvPlugin* plugin;
308 const LilvNode* ui_type;
311 LilvInstance* instance;
312 const LV2_Worker_Interface* work_iface;
313 #ifdef HAVE_LV2_1_2_0
314 const LV2_Options_Interface* opts_iface;
317 LV2_Atom_Forge forge;
318 LV2_Atom_Forge ui_forge;
319 int32_t block_length;
320 #ifdef HAVE_LV2_1_2_0
321 LV2_Options_Option* options;
324 LV2_Inline_Display* queue_draw;
329 LV2Plugin::LV2Plugin (AudioEngine& engine,
331 const void* c_plugin,
333 : Plugin (engine, session)
338 , _state_worker(NULL)
340 , _patch_port_in_index((uint32_t)-1)
341 , _patch_port_out_index((uint32_t)-1)
342 , _uri_map(URIMap::instance())
343 , _no_sample_accurate_ctrl (false)
345 init(c_plugin, rate);
348 LV2Plugin::LV2Plugin (const LV2Plugin& other)
354 , _state_worker(NULL)
355 , _insert_id(other._insert_id)
356 , _patch_port_in_index((uint32_t)-1)
357 , _patch_port_out_index((uint32_t)-1)
358 , _uri_map(URIMap::instance())
359 , _no_sample_accurate_ctrl (false)
361 init(other._impl->plugin, other._sample_rate);
363 for (uint32_t i = 0; i < parameter_count(); ++i) {
364 _control_data[i] = other._shadow_data[i];
365 _shadow_data[i] = other._shadow_data[i];
370 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
372 DEBUG_TRACE(DEBUG::LV2, "init\n");
374 _impl->plugin = (const LilvPlugin*)c_plugin;
376 _impl->ui_type = NULL;
381 _atom_ev_buffers = 0;
383 _bpm_control_port = 0;
384 _freewheel_control_port = 0;
385 _latency_control_port = 0;
386 _next_cycle_start = std::numeric_limits<framepos_t>::max();
387 _next_cycle_speed = 1.0;
388 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
390 _was_activated = false;
391 _has_state_interface = false;
392 _can_write_automation = false;
394 _current_latency = 0;
395 _impl->block_length = _session.get_block_size();
397 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
398 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
399 _make_path_feature.URI = LV2_STATE__makePath;
400 _log_feature.URI = LV2_LOG__log;
401 _work_schedule_feature.URI = LV2_WORKER__schedule;
402 _work_schedule_feature.data = NULL;
403 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
404 _def_state_feature.data = NULL;
406 const LilvPlugin* plugin = _impl->plugin;
408 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
409 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
410 _has_state_interface =
411 // What plugins should have (lv2:extensionData state:Interface)
412 lilv_plugin_has_extension_data(plugin, state_iface_uri)
413 // What some outdated/incorrect ones have
414 || lilv_plugin_has_feature(plugin, state_uri);
415 lilv_node_free(state_uri);
416 lilv_node_free(state_iface_uri);
418 _features = (LV2_Feature**)calloc(13, sizeof(LV2_Feature*));
419 _features[0] = &_instance_access_feature;
420 _features[1] = &_data_access_feature;
421 _features[2] = &_make_path_feature;
422 _features[3] = _uri_map.uri_map_feature();
423 _features[4] = _uri_map.urid_map_feature();
424 _features[5] = _uri_map.urid_unmap_feature();
425 _features[6] = &_log_feature;
427 unsigned n_features = 7;
428 #ifdef HAVE_LV2_1_2_0
429 _features[n_features++] = &_def_state_feature;
432 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
433 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
436 _impl->queue_draw = (LV2_Inline_Display*)
437 malloc (sizeof(LV2_Inline_Display));
438 _impl->queue_draw->handle = this;
439 _impl->queue_draw->queue_draw = queue_draw;
441 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
442 _queue_draw_feature.data = _impl->queue_draw;
443 _features[n_features++] = &_queue_draw_feature;
445 _impl->midnam = (LV2_Midnam*)
446 malloc (sizeof(LV2_Midnam));
447 _impl->midnam->handle = this;
448 _impl->midnam->update = midnam_update;
450 _midnam_feature.URI = LV2_MIDNAM__update;
451 _midnam_feature.data = _impl->midnam;
452 _features[n_features++] = &_midnam_feature;
455 #ifdef HAVE_LV2_1_2_0
456 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
457 static const int32_t _min_block_length = 1; // may happen during split-cycles
458 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
459 /* Consider updating max-block-size whenever the buffersize changes.
460 * It requires re-instantiating the plugin (which is a non-realtime operation),
461 * so it should be done lightly and only for plugins that require it.
463 * given that the block-size can change at any time (split-cycles) ardour currently
464 * does not support plugins that require bufz_fixedBlockLength.
466 LV2_Options_Option options[] = {
467 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
468 sizeof(int32_t), atom_Int, &_min_block_length },
469 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
470 sizeof(int32_t), atom_Int, &_max_block_length },
471 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
472 sizeof(int32_t), atom_Int, &_seq_size },
473 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
474 sizeof(int32_t), atom_Int, &_impl->block_length },
475 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
478 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
479 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
481 _options_feature.URI = LV2_OPTIONS__options;
482 _options_feature.data = _impl->options;
483 _features[n_features++] = &_options_feature;
486 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
487 sizeof(LV2_State_Make_Path));
488 make_path->handle = this;
489 make_path->path = &lv2_state_make_path;
490 _make_path_feature.data = make_path;
492 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
494 log->printf = &log_printf;
495 log->vprintf = &log_vprintf;
496 _log_feature.data = log;
498 const size_t ring_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
499 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
500 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
501 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
502 sizeof(LV2_Worker_Schedule));
503 _worker = new Worker(this, ring_size);
504 schedule->handle = _worker;
505 schedule->schedule_work = work_schedule;
506 _work_schedule_feature.data = schedule;
507 _features[n_features++] = &_work_schedule_feature;
509 lilv_node_free(worker_schedule);
511 if (_has_state_interface) {
512 // Create a non-threaded worker for use by state restore
513 _state_worker = new Worker(this, ring_size, false);
516 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
517 _impl->name = lilv_plugin_get_name(plugin);
518 _impl->author = lilv_plugin_get_author_name(plugin);
520 if (_impl->instance == 0) {
521 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
522 throw failed_constructor();
525 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
526 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
527 _data_access_feature.data = &_data_access_extension_data;
529 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
530 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
531 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
532 LV2_WORKER__interface);
534 lilv_node_free(worker_iface_uri);
537 #ifdef HAVE_LV2_1_2_0
538 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
539 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
540 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
541 LV2_OPTIONS__interface);
543 lilv_node_free(options_iface_uri);
547 _display_interface = (const LV2_Inline_Display_Interface*)
548 extension_data (LV2_INLINEDISPLAY__interface);
550 _midname_interface = (const LV2_Midnam_Interface*)
551 extension_data (LV2_MIDNAM__interface);
552 if (_midname_interface) {
557 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
558 error << string_compose(
559 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
560 lilv_node_as_string(_impl->name)) << endmsg;
561 lilv_node_free(_impl->name);
562 lilv_node_free(_impl->author);
563 throw failed_constructor();
566 #ifdef HAVE_LV2_1_2_0
567 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
568 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
569 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
571 error << string_compose(
572 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
573 lilv_node_as_string(_impl->name)) << endmsg;
574 lilv_node_free(_impl->name);
575 lilv_node_free(_impl->author);
576 lilv_nodes_free(required_features);
577 throw failed_constructor();
579 lilv_nodes_free(required_features);
582 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
583 #ifdef HAVE_LV2_1_2_0
584 if (lilv_nodes_contains (optional_features, _world.bufz_coarseBlockLength)) {
585 _no_sample_accurate_ctrl = true;
589 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
590 /* deprecated 2016-Sep-18 in favor of bufz_coarseBlockLength */
591 _no_sample_accurate_ctrl = true;
593 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
594 _can_write_automation = true;
596 lilv_nodes_free(optional_features);
599 #ifdef HAVE_LILV_0_16_0
600 // Load default state
602 /* immediately schedule any work,
603 * so that state restore later will not find a busy
604 * worker. latency_compute_run() flushes any replies
606 _worker->set_synchronous(true);
608 LilvState* state = lilv_state_new_from_world(
609 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
610 if (state && _has_state_interface) {
611 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
613 lilv_state_free(state);
618 const uint32_t num_ports = this->num_ports();
619 for (uint32_t i = 0; i < num_ports; ++i) {
620 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
622 size_t minimumSize = 0;
624 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
625 flags |= PORT_OUTPUT;
626 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
629 error << string_compose(
630 "LV2: \"%1\" port %2 is neither input nor output",
631 lilv_node_as_string(_impl->name), i) << endmsg;
632 throw failed_constructor();
635 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
636 flags |= PORT_CONTROL;
637 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
639 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
641 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
642 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
643 LilvNodes* buffer_types = lilv_port_get_value(
644 _impl->plugin, port, _world.atom_bufferType);
645 LilvNodes* atom_supports = lilv_port_get_value(
646 _impl->plugin, port, _world.atom_supports);
648 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
649 flags |= PORT_SEQUENCE;
650 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
653 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
654 flags |= PORT_POSITION;
657 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
658 flags |= PORT_AUTOCTRL;
661 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
662 flags |= PORT_PATCHMSG;
663 if (flags & PORT_INPUT) {
664 _patch_port_in_index = i;
666 _patch_port_out_index = i;
670 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
671 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
672 if (min_size && lilv_node_is_int(min_size)) {
673 minimumSize = lilv_node_as_int(min_size);
675 lilv_nodes_free(min_size_v);
676 lilv_nodes_free(buffer_types);
677 lilv_nodes_free(atom_supports);
679 error << string_compose(
680 "LV2: \"%1\" port %2 has no known data type",
681 lilv_node_as_string(_impl->name), i) << endmsg;
682 throw failed_constructor();
685 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
686 if (lilv_port_has_property(_impl->plugin, port, _world.ext_causesArtifacts)) {
687 flags |= PORT_NOAUTO;
689 if (lilv_port_has_property(_impl->plugin, port, _world.ext_notAutomatic)) {
690 flags |= PORT_NOAUTO;
692 if (lilv_port_has_property(_impl->plugin, port, _world.ext_expensive)) {
693 flags |= PORT_NOAUTO;
697 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
698 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
699 flags |= PORT_CTRLED;
702 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controller)) {
703 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
704 flags |= PORT_CTRLER;
709 _port_flags.push_back(flags);
710 _port_minimumSize.push_back(minimumSize);
711 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
714 _control_data = new float[num_ports];
715 _shadow_data = new float[num_ports];
716 _defaults = new float[num_ports];
717 _ev_buffers = new LV2_Evbuf*[num_ports];
718 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
720 const bool latent = lilv_plugin_has_latency(plugin);
721 const uint32_t latency_index = (latent)
722 ? lilv_plugin_get_latency_port_index(plugin)
725 // Build an array of pointers to special parameter buffers
726 void*** params = new void**[num_ports];
727 for (uint32_t i = 0; i < num_ports; ++i) {
730 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
731 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
733 for (uint32_t i = 0; i < num_ports; ++i) {
734 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
735 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
737 // Store index in map so we can look up index by symbol
738 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
740 // Get range and default value if applicable
741 if (parameter_is_control(i)) {
743 lilv_port_get_range(plugin, port, &def, NULL, NULL);
744 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
745 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
746 _defaults[i] *= _session.frame_rate ();
750 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
752 if (latent && i == latency_index) {
754 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
755 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
756 _latency_control_port = &_control_data[i];
757 *_latency_control_port = 0;
760 if (parameter_is_input(i)) {
761 _shadow_data[i] = default_value(i);
763 *params[i] = (void*)&_shadow_data[i];
773 LilvUIs* uis = lilv_plugin_get_uis(plugin);
774 if (lilv_uis_size(uis) > 0) {
776 // Look for embeddable UI
777 LILV_FOREACH(uis, u, uis) {
778 const LilvUI* this_ui = lilv_uis_get(uis, u);
779 const LilvNode* this_ui_type = NULL;
780 if (lilv_ui_is_supported(this_ui,
784 // TODO: Multiple UI support
786 _impl->ui_type = this_ui_type;
791 // Look for Gtk native UI
792 LILV_FOREACH(uis, i, uis) {
793 const LilvUI* ui = lilv_uis_get(uis, i);
794 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
796 _impl->ui_type = _world.ui_GtkUI;
802 // If Gtk UI is not available, try to find external UI
804 LILV_FOREACH(uis, i, uis) {
805 const LilvUI* ui = lilv_uis_get(uis, i);
806 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
808 _impl->ui_type = _world.ui_external;
811 if (lilv_ui_is_a(ui, _world.ui_external)) {
813 _impl->ui_type = _world.ui_external;
819 load_supported_properties(_property_descriptors);
820 allocate_atom_event_buffers();
821 latency_compute_run();
825 LV2Plugin::set_block_size (pframes_t nframes)
827 #ifdef HAVE_LV2_1_2_0
828 if (_impl->opts_iface) {
829 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
830 _impl->block_length = nframes;
831 LV2_Options_Option block_size_option = {
832 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
833 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
835 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
842 LV2Plugin::requires_fixed_sized_buffers () const
844 /* This controls if Ardour will split the plugin's run()
845 * on automation events in order to pass sample-accurate automation
846 * via standard control-ports.
848 * When returning true Ardour will *not* sub-divide the process-cycle.
849 * Automation events that happen between cycle-start and cycle-end will be
850 * ignored (ctrl values are interpolated to cycle-start).
851 * NB. Atom Sequences are still sample accurate.
853 * Note: This does not guarantee a fixed block-size.
854 * e.g The process cycle may be split when looping, also
855 * the period-size may change any time: see set_block_size()
857 if (get_info()->n_inputs.n_midi() > 0) {
858 /* we don't yet implement midi buffer offsets (for split cycles).
859 * Also connect_and_run() also uses _session.transport_frame() directly
860 * (for BBT) which is not offset for plugin cycle split.
864 return _no_sample_accurate_ctrl;
867 LV2Plugin::~LV2Plugin ()
869 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
876 std::stringstream ss;
879 MIDI::Name::MidiPatchManager::instance().remove_custom_midnam (ss.str());
883 lilv_instance_free(_impl->instance);
884 lilv_state_free(_impl->state);
885 lilv_node_free(_impl->name);
886 lilv_node_free(_impl->author);
887 #ifdef HAVE_LV2_1_2_0
888 free(_impl->options);
891 free(_impl->queue_draw);
896 free(_log_feature.data);
897 free(_make_path_feature.data);
898 free(_work_schedule_feature.data);
903 delete _state_worker;
905 if (_atom_ev_buffers) {
906 LV2_Evbuf** b = _atom_ev_buffers;
911 free(_atom_ev_buffers);
914 delete [] _control_data;
915 delete [] _shadow_data;
917 delete [] _ev_buffers;
922 LV2Plugin::is_external_ui() const
927 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
931 LV2Plugin::is_external_kx() const
936 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
940 LV2Plugin::ui_is_resizable () const
942 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
943 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
944 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
945 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
947 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
948 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
950 lilv_nodes_free(nrs_matches);
951 lilv_nodes_free(fs_matches);
956 return !fs_matches && !nrs_matches;
961 LV2Plugin::has_inline_display () {
962 return _display_interface ? true : false;
965 Plugin::Display_Image_Surface*
966 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
967 if (_display_interface) {
968 /* Plugin::Display_Image_Surface is identical to
969 * LV2_Inline_Display_Image_Surface */
970 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
976 LV2Plugin::has_midnam () {
977 return _midname_interface ? true : false;
981 LV2Plugin::read_midnam () {
983 if (!_midname_interface) {
986 char* midnam = _midname_interface->midnam ((void*)_impl->instance->lv2_handle);
988 std::stringstream ss;
991 rv = MIDI::Name::MidiPatchManager::instance().update_custom_midnam (ss.str(), midnam);
995 info << string_compose(_("LV2: update midnam for plugin '%1'"), name ()) << endmsg;
997 warning << string_compose(_("LV2: Failed to parse midnam of plugin '%1'"), name ()) << endmsg;
1000 _midname_interface->free (midnam);
1005 LV2Plugin::midnam_model () {
1007 if (!_midname_interface) {
1010 char* model = _midname_interface->model ((void*)_impl->instance->lv2_handle);
1014 _midname_interface->free (model);
1020 LV2Plugin::unique_id() const
1022 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1026 LV2Plugin::uri() const
1028 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1032 LV2Plugin::label() const
1034 return lilv_node_as_string(_impl->name);
1038 LV2Plugin::name() const
1040 return lilv_node_as_string(_impl->name);
1044 LV2Plugin::maker() const
1046 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
1050 LV2Plugin::num_ports() const
1052 return lilv_plugin_get_num_ports(_impl->plugin);
1056 LV2Plugin::parameter_count() const
1058 return lilv_plugin_get_num_ports(_impl->plugin);
1062 LV2Plugin::default_value(uint32_t port)
1064 return _defaults[port];
1068 LV2Plugin::port_symbol(uint32_t index) const
1070 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
1072 error << name() << ": Invalid port index " << index << endmsg;
1075 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
1076 return lilv_node_as_string(sym);
1080 LV2Plugin::port_index (const char* symbol) const
1082 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
1083 if (i != _port_indices.end()) {
1086 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
1087 return (uint32_t)-1;
1092 LV2Plugin::set_parameter(uint32_t which, float val)
1094 DEBUG_TRACE(DEBUG::LV2, string_compose(
1095 "%1 set parameter %2 to %3\n", name(), which, val));
1097 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
1098 if (get_parameter (which) == val) {
1102 _shadow_data[which] = val;
1104 warning << string_compose(
1105 _("Illegal parameter number used with plugin \"%1\". "
1106 "This is a bug in either %2 or the LV2 plugin <%3>"),
1107 name(), PROGRAM_NAME, unique_id()) << endmsg;
1110 Plugin::set_parameter(which, val);
1114 LV2Plugin::get_parameter(uint32_t which) const
1116 if (parameter_is_input(which)) {
1117 return (float)_shadow_data[which];
1119 return (float)_control_data[which];
1125 LV2Plugin::get_docs() const
1127 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1129 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1130 lilv_nodes_free(comments);
1138 LV2Plugin::get_parameter_docs(uint32_t which) const
1140 LilvNodes* comments = lilv_port_get_value(
1142 lilv_plugin_get_port_by_index(_impl->plugin, which),
1143 _world.rdfs_comment);
1146 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1147 lilv_nodes_free(comments);
1155 LV2Plugin::get_layout (uint32_t which, UILayoutHint& h) const
1157 /// TODO lookup port-properties
1158 if (unique_id () != "urn:ardour:a-eq") {
1163 case 0: h.x0 = 0; h.x1 = 1; h.y0 = 2; h.y1 = 3; break; // Frequency L
1164 case 1: h.x0 = 0; h.x1 = 1; h.y0 = 0; h.y1 = 1; break; // Gain L
1165 case 17: h.x0 = 0; h.x1 = 1; h.y0 = 5; h.y1 = 6; break; // enable L
1167 case 2: h.x0 = 1; h.x1 = 3; h.y0 = 2; h.y1 = 3; break; // Frequency 1
1168 case 3: h.x0 = 1; h.x1 = 3; h.y0 = 0; h.y1 = 1; break; // Gain 1
1169 case 4: h.x0 = 1; h.x1 = 3; h.y0 = 1; h.y1 = 2; break; // Bandwidth 1
1170 case 18: h.x0 = 1; h.x1 = 4; h.y0 = 5; h.y1 = 6; break; // enable 1
1172 case 5: h.x0 = 4; h.x1 = 6; h.y0 = 2; h.y1 = 3; break; // Frequency 2
1173 case 6: h.x0 = 4; h.x1 = 6; h.y0 = 0; h.y1 = 1; break; // Gain 2
1174 case 7: h.x0 = 4; h.x1 = 6; h.y0 = 1; h.y1 = 2; break; // Bandwidth 2
1175 case 19: h.x0 = 4; h.x1 = 7; h.y0 = 5; h.y1 = 6; break; // enable 2
1177 case 8: h.x0 = 7; h.x1 = 9; h.y0 = 2; h.y1 = 3; break; // Frequency 3
1178 case 9: h.x0 = 7; h.x1 = 9; h.y0 = 0; h.y1 = 1; break; // Gain 3
1179 case 10: h.x0 = 7; h.x1 = 9; h.y0 = 1; h.y1 = 2; break; // Bandwidth 3
1180 case 20: h.x0 = 7; h.x1 = 10; h.y0 = 5; h.y1 = 6; break; // enable 3
1182 case 11: h.x0 = 10; h.x1 = 12; h.y0 = 2; h.y1 = 3; break; // Frequency 4
1183 case 12: h.x0 = 10; h.x1 = 12; h.y0 = 0; h.y1 = 1; break; // Gain 4
1184 case 13: h.x0 = 10; h.x1 = 12; h.y0 = 1; h.y1 = 2; break; // Bandwidth 4
1185 case 21: h.x0 = 10; h.x1 = 13; h.y0 = 5; h.y1 = 6; break; // enable 4
1187 case 14: h.x0 = 13; h.x1 = 14; h.y0 = 2; h.y1 = 3; break; // Frequency H
1188 case 15: h.x0 = 13; h.x1 = 14; h.y0 = 0; h.y1 = 1; break; // Gain H
1189 case 22: h.x0 = 13; h.x1 = 14; h.y0 = 5; h.y1 = 6; break; // enable H
1191 case 16: h.x0 = 14; h.x1 = 15; h.y0 = 1; h.y1 = 3; break; // Master Gain
1192 case 23: h.x0 = 14; h.x1 = 15; h.y0 = 5; h.y1 = 6; break; // Master Enable
1200 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1203 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1204 if (parameter_is_control(x)) {
1216 LV2Plugin::extension_data(const char* uri) const
1218 return lilv_instance_get_extension_data(_impl->instance, uri);
1222 LV2Plugin::c_plugin()
1224 return _impl->plugin;
1230 return (const void*)_impl->ui;
1234 LV2Plugin::c_ui_type()
1236 return (const void*)_impl->ui_type;
1239 /** Directory for all plugin state. */
1241 LV2Plugin::plugin_dir() const
1243 if (!_plugin_state_dir.empty ()){
1244 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1246 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1250 /** Directory for files created by the plugin (except during save). */
1252 LV2Plugin::scratch_dir() const
1254 return Glib::build_filename(plugin_dir(), "scratch");
1257 /** Directory for snapshots of files in the scratch directory. */
1259 LV2Plugin::file_dir() const
1261 return Glib::build_filename(plugin_dir(), "files");
1264 /** Directory to save state snapshot version @c num into. */
1266 LV2Plugin::state_dir(unsigned num) const
1268 return Glib::build_filename(plugin_dir(), string("state") + PBD::to_string (num));
1271 /** Implementation of state:makePath for files created at instantiation time.
1272 * Note this is not used for files created at save time (Lilv deals with that).
1275 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1278 LV2Plugin* me = (LV2Plugin*)handle;
1279 if (me->_insert_id == PBD::ID("0")) {
1280 warning << string_compose(
1281 "File path \"%1\" requested but LV2 %2 has no insert ID",
1282 path, me->name()) << endmsg;
1283 return g_strdup(path);
1286 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1287 const std::string dirname = Glib::path_get_dirname(abs_path);
1288 g_mkdir_with_parents(dirname.c_str(), 0744);
1290 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1293 return g_strndup(abs_path.c_str(), abs_path.length());
1297 LV2Plugin::add_state(XMLNode* root) const
1299 assert(_insert_id != PBD::ID("0"));
1304 for (uint32_t i = 0; i < parameter_count(); ++i) {
1305 if (parameter_is_input(i) && parameter_is_control(i)) {
1306 child = new XMLNode("Port");
1307 child->set_property("symbol", port_symbol(i));
1308 child->set_property("value", _shadow_data[i]);
1309 root->add_child_nocopy(*child);
1313 if (!_plugin_state_dir.empty()) {
1314 root->set_property("template-dir", _plugin_state_dir);
1317 if (_has_state_interface) {
1318 // Provisionally increment state version and create directory
1319 const std::string new_dir = state_dir(++_state_version);
1320 // and keep track of it (for templates & archive)
1321 unsigned int saved_state = _state_version;;
1322 g_mkdir_with_parents(new_dir.c_str(), 0744);
1324 LilvState* state = lilv_state_new_from_instance(
1327 _uri_map.urid_map(),
1328 scratch_dir().c_str(),
1330 _session.externals_dir().c_str(),
1333 const_cast<LV2Plugin*>(this),
1337 if (!_plugin_state_dir.empty() || force_state_save
1339 || !lilv_state_equals(state, _impl->state)) {
1340 lilv_state_save(_world.world,
1341 _uri_map.urid_map(),
1342 _uri_map.urid_unmap(),
1348 if (force_state_save) {
1349 // archive or save-as
1350 lilv_state_free(state);
1353 else if (_plugin_state_dir.empty()) {
1354 // normal session save
1355 lilv_state_free(_impl->state);
1356 _impl->state = state;
1358 // template save (dedicated state-dir)
1359 lilv_state_free(state);
1363 // State is identical, decrement version and nuke directory
1364 lilv_state_free(state);
1365 PBD::remove_directory(new_dir);
1367 saved_state = _state_version;
1370 root->set_property("state-dir", string("state") + PBD::to_string (saved_state));
1374 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1376 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1378 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1380 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1381 lilv_nodes_free(vs);
1388 LV2Plugin::find_presets()
1390 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1391 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1392 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1394 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1395 LILV_FOREACH(nodes, i, presets) {
1396 const LilvNode* preset = lilv_nodes_get(presets, i);
1397 lilv_world_load_resource(_world.world, preset);
1398 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1399 bool userpreset = true; // TODO
1401 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1402 Plugin::PresetRecord(
1403 lilv_node_as_string(preset),
1404 lilv_node_as_string(name),
1406 lilv_node_free(name);
1408 warning << string_compose(
1409 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1410 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1411 lilv_node_as_string(preset)) << endmsg;
1414 lilv_nodes_free(presets);
1416 lilv_node_free(rdfs_label);
1417 lilv_node_free(pset_Preset);
1418 lilv_node_free(lv2_appliesTo);
1422 set_port_value(const char* port_symbol,
1428 LV2Plugin* self = (LV2Plugin*)user_data;
1429 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1430 return; // TODO: Support non-float ports
1433 const uint32_t port_index = self->port_index(port_symbol);
1434 if (port_index != (uint32_t)-1) {
1435 self->set_parameter(port_index, *(const float*)value);
1436 self->PresetPortSetValue (port_index, *(const float*)value); /* EMIT SIGNAL */
1441 LV2Plugin::load_preset(PresetRecord r)
1443 LilvWorld* world = _world.world;
1444 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1445 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1447 const LV2_Feature* state_features[2] = { NULL, NULL };
1448 LV2_Worker_Schedule schedule = { _state_worker, work_schedule };
1449 const LV2_Feature state_sched_feature = { LV2_WORKER__schedule, &schedule };
1450 if (_state_worker) {
1451 state_features[0] = &state_sched_feature;
1455 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, state_features);
1456 lilv_state_free(state);
1457 Plugin::load_preset(r);
1460 lilv_node_free(pset);
1465 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1470 LV2Plugin *plugin = (LV2Plugin *) user_data;
1472 uint32_t index = plugin->port_index(port_symbol);
1473 if (index != (uint32_t) -1) {
1474 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1476 *size = sizeof(float);
1477 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1478 value = &plugin->_shadow_data[index];
1490 LV2Plugin::do_save_preset(string name)
1492 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1493 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1494 const string base_name = legalize_for_uri(name);
1495 const string file_name = base_name + ".ttl";
1496 const string bundle = Glib::build_filename(
1497 Glib::get_home_dir(),
1498 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1500 #ifdef HAVE_LILV_0_21_3
1501 /* delete reference to old preset (if any) */
1502 const PresetRecord* r = preset_by_label(name);
1504 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1506 lilv_world_unload_resource (_world.world, pset);
1507 lilv_node_free(pset);
1512 LilvState* state = lilv_state_new_from_instance(
1515 _uri_map.urid_map(),
1516 scratch_dir().c_str(), // file_dir
1517 bundle.c_str(), // copy_dir
1518 bundle.c_str(), // link_dir
1519 bundle.c_str(), // save_dir
1520 lv2plugin_get_port_value, // get_value
1521 (void*)this, // user_data
1522 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1523 _features // features
1526 lilv_state_set_label(state, name.c_str());
1528 _world.world, // world
1529 _uri_map.urid_map(), // map
1530 _uri_map.urid_unmap(), // unmap
1532 NULL, // uri (NULL = use file URI)
1533 bundle.c_str(), // dir
1534 file_name.c_str() // filename
1537 lilv_state_free(state);
1539 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1540 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1541 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1542 #ifdef HAVE_LILV_0_21_3
1543 lilv_world_unload_resource(_world.world, node_preset);
1544 lilv_world_unload_bundle(_world.world, node_bundle);
1546 lilv_world_load_bundle(_world.world, node_bundle);
1547 lilv_world_load_resource(_world.world, node_preset);
1548 lilv_node_free(node_bundle);
1549 lilv_node_free(node_preset);
1550 lilv_node_free(plug_name);
1555 LV2Plugin::do_remove_preset(string name)
1557 #ifdef HAVE_LILV_0_21_3
1558 /* Look up preset record by label (FIXME: ick, label as ID) */
1559 const PresetRecord* r = preset_by_label(name);
1564 /* Load a LilvState for the preset. */
1565 LilvWorld* world = _world.world;
1566 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1567 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1569 lilv_node_free(pset);
1573 /* Unload preset from world. */
1574 lilv_world_unload_resource(world, pset);
1576 /* Delete it from the file system. This will remove the preset file and the entry
1577 from the manifest. If this results in an empty manifest (i.e. the
1578 preset is the only thing in the bundle), then the bundle is removed. */
1579 lilv_state_delete(world, state);
1581 lilv_state_free(state);
1582 lilv_node_free(pset);
1584 /* Without lilv_state_delete(), we could delete the preset file, but this
1585 would leave a broken bundle/manifest around, so the preset would still
1586 be visible, but broken. Naively deleting a bundle is too dangerous, so
1587 we simply do not support preset deletion with older Lilv */
1591 LV2Plugin::has_editor() const
1593 return _impl->ui != NULL;
1597 LV2Plugin::has_message_output() const
1599 for (uint32_t i = 0; i < num_ports(); ++i) {
1600 if ((_port_flags[i] & PORT_SEQUENCE) &&
1601 (_port_flags[i] & PORT_OUTPUT)) {
1609 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1613 const uint8_t* body)
1615 const uint32_t buf_size = sizeof(UIMessage) + size;
1616 vector<uint8_t> buf(buf_size);
1618 UIMessage* msg = (UIMessage*)&buf[0];
1620 msg->protocol = protocol;
1622 memcpy(msg + 1, body, size);
1624 return (dest->write(&buf[0], buf_size) == buf_size);
1628 LV2Plugin::write_from_ui(uint32_t index,
1631 const uint8_t* body)
1634 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1635 /* buffer data communication from plugin UI to plugin instance.
1636 * this buffer needs to potentially hold
1637 * (port's minimumSize) * (audio-periods) / (UI-periods)
1640 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1641 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1642 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1644 * it is NOT safe to overflow (msg.size will be misinterpreted)
1646 uint32_t bufsiz = 32768;
1647 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1648 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1650 int fact = ceilf(_session.frame_rate () / 3000.f);
1651 rbs = max((size_t) bufsiz * std::max (8, fact), rbs);
1652 _from_ui = new RingBuffer<uint8_t>(rbs);
1655 if (!write_to(_from_ui, index, protocol, size, body)) {
1656 error << "Error writing from UI to plugin" << endmsg;
1663 LV2Plugin::write_to_ui(uint32_t index,
1666 const uint8_t* body)
1668 if (!write_to(_to_ui, index, protocol, size, body)) {
1669 error << "Error writing from plugin to UI" << endmsg;
1676 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1678 switch (value.type()) {
1679 case Variant::NOTHING:
1681 case Variant::BEATS:
1682 // No atom type for this, just forge a double
1683 lv2_atom_forge_double(forge, value.get_beats().to_double());
1686 lv2_atom_forge_bool(forge, value.get_bool());
1688 case Variant::DOUBLE:
1689 lv2_atom_forge_double(forge, value.get_double());
1691 case Variant::FLOAT:
1692 lv2_atom_forge_float(forge, value.get_float());
1695 lv2_atom_forge_int(forge, value.get_int());
1698 lv2_atom_forge_long(forge, value.get_long());
1701 lv2_atom_forge_path(
1702 forge, value.get_path().c_str(), value.get_path().size());
1704 case Variant::STRING:
1705 lv2_atom_forge_string(
1706 forge, value.get_string().c_str(), value.get_string().size());
1710 forge, value.get_uri().c_str(), value.get_uri().size());
1715 /** Get a variant type from a URI, return false iff no match found. */
1717 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1719 if (uri == LV2_ATOM__Bool) {
1720 type = Variant::BOOL;
1721 } else if (uri == LV2_ATOM__Double) {
1722 type = Variant::DOUBLE;
1723 } else if (uri == LV2_ATOM__Float) {
1724 type = Variant::FLOAT;
1725 } else if (uri == LV2_ATOM__Int) {
1726 type = Variant::INT;
1727 } else if (uri == LV2_ATOM__Long) {
1728 type = Variant::LONG;
1729 } else if (uri == LV2_ATOM__Path) {
1730 type = Variant::PATH;
1731 } else if (uri == LV2_ATOM__String) {
1732 type = Variant::STRING;
1733 } else if (uri == LV2_ATOM__URI) {
1734 type = Variant::URI;
1742 LV2Plugin::set_property(uint32_t key, const Variant& value)
1744 if (_patch_port_in_index == (uint32_t)-1) {
1745 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1747 } else if (value.type() == Variant::NOTHING) {
1748 error << "LV2: set_property called with void value" << endmsg;
1752 // Set up forge to write to temporary buffer on the stack
1753 LV2_Atom_Forge* forge = &_impl->ui_forge;
1754 LV2_Atom_Forge_Frame frame;
1755 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1757 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1759 // Serialize patch:Set message to set property
1760 #ifdef HAVE_LV2_1_10_0
1761 lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Set);
1762 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1763 lv2_atom_forge_urid(forge, key);
1764 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1766 lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Set);
1767 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1768 lv2_atom_forge_urid(forge, key);
1769 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1772 forge_variant(forge, value);
1774 // Write message to UI=>Plugin ring
1775 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1776 write_from_ui(_patch_port_in_index,
1777 _uri_map.urids.atom_eventTransfer,
1778 lv2_atom_total_size(atom),
1779 (const uint8_t*)atom);
1782 const ParameterDescriptor&
1783 LV2Plugin::get_property_descriptor(uint32_t id) const
1785 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1786 if (p != _property_descriptors.end()) {
1789 return Plugin::get_property_descriptor(id);
1793 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1795 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1796 desc.unit = ParameterDescriptor::MIDI_NOTE;
1797 } else if (lilv_nodes_contains(units, _world.units_db)) {
1798 desc.unit = ParameterDescriptor::DB;
1799 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1800 desc.unit = ParameterDescriptor::HZ;
1802 if (lilv_nodes_size(units) > 0) {
1803 const LilvNode* unit = lilv_nodes_get_first(units);
1804 LilvNode* render = get_value(lworld, unit, _world.units_render);
1806 desc.print_fmt = lilv_node_as_string(render);
1807 /* override lilv's default "%f" format */
1808 if (desc.integer_step) {
1809 replace_all (desc.print_fmt, "%f", "%d");
1810 } else if (desc.upper - desc.lower >= 1000) {
1811 replace_all (desc.print_fmt, "%f", "%.1f");
1812 } else if (desc.upper - desc.lower >= 100) {
1813 replace_all (desc.print_fmt, "%f", "%.2f");
1815 replace_all (desc.print_fmt, "%f", "%.3f");
1817 lilv_node_free(render);
1823 load_parameter_descriptor(LV2World& world,
1824 ParameterDescriptor& desc,
1825 Variant::Type datatype,
1826 const LilvNode* subject)
1828 LilvWorld* lworld = _world.world;
1829 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1830 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1831 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1832 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1833 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1835 desc.label = lilv_node_as_string(label);
1838 if (lilv_node_is_float(def)) {
1839 desc.normal = lilv_node_as_float(def);
1840 } else if (lilv_node_is_int(def)) {
1841 desc.normal = lilv_node_as_int(def);
1845 if (lilv_node_is_float(minimum)) {
1846 desc.lower = lilv_node_as_float(minimum);
1847 } else if (lilv_node_is_int(minimum)) {
1848 desc.lower = lilv_node_as_int(minimum);
1852 if (lilv_node_is_float(maximum)) {
1853 desc.upper = lilv_node_as_float(maximum);
1854 } else if (lilv_node_is_int(maximum)) {
1855 desc.upper = lilv_node_as_int(maximum);
1858 load_parameter_descriptor_units(lworld, desc, units);
1859 desc.datatype = datatype;
1860 desc.toggled |= datatype == Variant::BOOL;
1861 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1862 desc.update_steps();
1864 lilv_nodes_free(units);
1865 lilv_node_free(label);
1866 lilv_node_free(def);
1867 lilv_node_free(minimum);
1868 lilv_node_free(maximum);
1872 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1874 LilvWorld* lworld = _world.world;
1875 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1876 LilvNodes* properties = lilv_world_find_nodes(
1877 lworld, subject, _world.patch_writable, NULL);
1878 LILV_FOREACH(nodes, p, properties) {
1879 // Get label and range
1880 const LilvNode* prop = lilv_nodes_get(properties, p);
1881 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1883 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1884 lilv_node_as_uri(prop)) << endmsg;
1888 // Convert range to variant type (TODO: support for multiple range types)
1889 Variant::Type datatype;
1890 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1891 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1892 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1896 // Add description to result
1897 ParameterDescriptor desc;
1898 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1899 desc.datatype = datatype;
1900 load_parameter_descriptor(_world, desc, datatype, prop);
1901 descs.insert(std::make_pair(desc.key, desc));
1903 lilv_node_free(range);
1905 lilv_nodes_free(properties);
1909 LV2Plugin::announce_property_values()
1911 if (_patch_port_in_index == (uint32_t)-1) {
1915 // Set up forge to write to temporary buffer on the stack
1916 LV2_Atom_Forge* forge = &_impl->ui_forge;
1917 LV2_Atom_Forge_Frame frame;
1918 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1920 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1922 // Serialize patch:Get message with no subject (implicitly plugin instance)
1923 #ifdef HAVE_LV2_1_10_0
1924 lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Get);
1926 lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Get);
1929 // Write message to UI=>Plugin ring
1930 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1931 write_from_ui(_patch_port_in_index,
1932 _uri_map.urids.atom_eventTransfer,
1933 lv2_atom_total_size(atom),
1934 (const uint8_t*)atom);
1938 LV2Plugin::enable_ui_emission()
1941 /* see note in LV2Plugin::write_from_ui() */
1942 uint32_t bufsiz = 32768;
1943 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1944 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1946 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1947 rbs = max((size_t) bufsiz * 8, rbs);
1948 _to_ui = new RingBuffer<uint8_t>(rbs);
1953 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1959 uint32_t read_space = _to_ui->read_space();
1960 while (read_space > sizeof(UIMessage)) {
1962 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1963 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1966 vector<uint8_t> body(msg.size);
1967 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1968 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1972 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1974 read_space -= sizeof(msg) + msg.size;
1979 LV2Plugin::work(Worker& worker, uint32_t size, const void* data)
1981 Glib::Threads::Mutex::Lock lm(_work_mutex);
1982 return _impl->work_iface->work(
1983 _impl->instance->lv2_handle, work_respond, &worker, size, data);
1987 LV2Plugin::work_response(uint32_t size, const void* data)
1989 return _impl->work_iface->work_response(
1990 _impl->instance->lv2_handle, size, data);
1994 LV2Plugin::set_insert_id(PBD::ID id)
1996 if (_insert_id == "0") {
1998 } else if (_insert_id != id) {
1999 lilv_state_free(_impl->state);
2000 _impl->state = NULL;
2006 LV2Plugin::set_state_dir (const std::string& d)
2008 _plugin_state_dir = d;
2012 LV2Plugin::set_state(const XMLNode& node, int version)
2015 XMLNodeConstIterator iter;
2019 if (node.name() != state_node_name()) {
2020 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
2024 #ifndef NO_PLUGIN_STATE
2026 if (version < 3000) {
2027 nodes = node.children("port");
2029 nodes = node.children("Port");
2032 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
2037 if (!child->get_property("symbol", sym)) {
2038 warning << _("LV2: port has no symbol, ignored") << endmsg;
2042 map<string, uint32_t>::iterator i = _port_indices.find(sym);
2046 if (i != _port_indices.end()) {
2047 port_id = i->second;
2049 warning << _("LV2: port has unknown index, ignored") << endmsg;
2054 if (!child->get_property("value", val)) {
2055 warning << _("LV2: port has no value, ignored") << endmsg;
2059 set_parameter(port_id, val);
2062 std::string template_dir;
2063 if (node.get_property("template-dir", template_dir)) {
2064 set_state_dir (template_dir);
2068 std::string state_dir;
2069 if (node.get_property("state-dir", state_dir) != 0) {
2070 if (sscanf(state_dir.c_str(), "state%u", &_state_version) != 1) {
2071 error << string_compose(
2072 "LV2: failed to parse state version from \"%1\"",
2073 state_dir) << endmsg;
2076 std::string state_file = Glib::build_filename(
2078 Glib::build_filename(state_dir, "state.ttl"));
2080 LilvState* state = lilv_state_new_from_file(
2081 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
2083 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
2084 lilv_state_free(_impl->state);
2085 _impl->state = state;
2088 if (!_plugin_state_dir.empty ()) {
2089 // force save with session, next time (increment counter)
2090 lilv_state_free (_impl->state);
2091 _impl->state = NULL;
2095 latency_compute_run();
2098 return Plugin::set_state(node, version);
2102 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
2104 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
2106 error << string_compose("LV2: get descriptor of non-existent port %1", which)
2111 LilvNodes* portunits;
2112 LilvNode *def, *min, *max;
2113 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
2114 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
2116 LilvNode* steps = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
2118 // TODO: Once we can rely on lilv 0.18.0 being present,
2119 // load_parameter_descriptor() can be used for ports as well
2120 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
2121 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
2122 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
2123 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
2124 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
2125 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
2126 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
2127 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
2128 load_parameter_descriptor_units(_world.world, desc, portunits);
2130 if (desc.sr_dependent) {
2131 desc.lower *= _session.frame_rate ();
2132 desc.upper *= _session.frame_rate ();
2135 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
2136 desc.scale_points = get_scale_points(which);
2139 desc.rangesteps = lilv_node_as_float (steps);
2142 desc.update_steps();
2144 lilv_node_free(def);
2145 lilv_node_free(min);
2146 lilv_node_free(max);
2147 lilv_node_free(steps);
2148 lilv_nodes_free(portunits);
2153 Plugin::IOPortDescription
2154 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2156 PortFlags match = 0;
2158 case DataType::AUDIO:
2161 case DataType::MIDI:
2162 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2165 return Plugin::IOPortDescription ("?");
2169 match |= PORT_INPUT;
2171 match |= PORT_OUTPUT;
2175 uint32_t idx = UINT32_MAX;
2177 uint32_t const num_ports = parameter_count();
2178 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2179 PortFlags flags = _port_flags[port_index];
2180 if ((flags & match) == match) {
2187 if (idx == UINT32_MAX) {
2188 return Plugin::IOPortDescription ("?");
2191 const LilvPort* pport = lilv_plugin_get_port_by_index (_impl->plugin, idx);
2193 LilvNode* name = lilv_port_get_name(_impl->plugin, pport);
2194 Plugin::IOPortDescription iod (lilv_node_as_string (name));
2195 lilv_node_free(name);
2197 /* get the port's pg:group */
2198 LilvNodes* groups = lilv_port_get_value (_impl->plugin, pport, _world.groups_group);
2199 if (lilv_nodes_size (groups) > 0) {
2200 const LilvNode* group = lilv_nodes_get_first (groups);
2201 LilvNodes* grouplabel = lilv_world_find_nodes (_world.world, group, _world.rdfs_label, NULL);
2203 /* get the name of the port-group */
2204 if (lilv_nodes_size (grouplabel) > 0) {
2205 const LilvNode* grpname = lilv_nodes_get_first (grouplabel);
2206 iod.group_name = lilv_node_as_string (grpname);
2208 lilv_nodes_free (grouplabel);
2210 /* get all port designations.
2211 * we're interested in e.g. lv2:designation pg:right */
2212 LilvNodes* designations = lilv_port_get_value (_impl->plugin, pport, _world.lv2_designation);
2213 if (lilv_nodes_size (designations) > 0) {
2214 /* get all pg:elements of the pg:group */
2215 LilvNodes* group_childs = lilv_world_find_nodes (_world.world, group, _world.groups_element, NULL);
2216 if (lilv_nodes_size (group_childs) > 0) {
2217 /* iterate over all port designations .. */
2218 LILV_FOREACH (nodes, i, designations) {
2219 const LilvNode* designation = lilv_nodes_get (designations, i);
2220 /* match the lv2:designation's element against the port-group's element */
2221 LILV_FOREACH (nodes, j, group_childs) {
2222 const LilvNode* group_element = lilv_nodes_get (group_childs, j);
2223 LilvNodes* elem = lilv_world_find_nodes (_world.world, group_element, _world.lv2_designation, designation);
2224 /* found it. Now look up the index (channel-number) of the pg:Element */
2225 if (lilv_nodes_size (elem) > 0) {
2226 LilvNodes* idx = lilv_world_find_nodes (_world.world, lilv_nodes_get_first (elem), _world.lv2_index, NULL);
2227 if (lilv_node_is_int (lilv_nodes_get_first (idx))) {
2228 iod.group_channel = lilv_node_as_int(lilv_nodes_get_first (idx));
2235 lilv_nodes_free (groups);
2236 lilv_nodes_free (designations);
2239 if (lilv_port_has_property(_impl->plugin, pport, _world.lv2_isSideChain)) {
2240 iod.is_sidechain = true;
2246 LV2Plugin::describe_parameter(Evoral::Parameter which)
2248 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2250 if (lilv_port_has_property(_impl->plugin,
2251 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2252 return X_("hidden");
2255 if (lilv_port_has_property(_impl->plugin,
2256 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2257 return X_("hidden");
2260 if (lilv_port_has_property(_impl->plugin,
2261 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2262 return X_("latency");
2265 LilvNode* name = lilv_port_get_name(_impl->plugin,
2266 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2267 string ret(lilv_node_as_string(name));
2268 lilv_node_free(name);
2276 LV2Plugin::max_latency () const
2278 return _max_latency;
2282 LV2Plugin::signal_latency() const
2284 if (_latency_control_port) {
2285 return (framecnt_t)floor(*_latency_control_port);
2291 set<Evoral::Parameter>
2292 LV2Plugin::automatable() const
2294 set<Evoral::Parameter> ret;
2296 for (uint32_t i = 0; i < parameter_count(); ++i) {
2297 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2298 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2302 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2303 p != _property_descriptors.end();
2305 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2311 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2313 if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2314 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2315 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2319 LV2Plugin::AutomationCtrlPtr
2320 LV2Plugin::get_automation_control (uint32_t i)
2322 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2323 return AutomationCtrlPtr ();
2325 return _ctrl_map[i];
2329 LV2Plugin::activate()
2331 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2333 if (!_was_activated) {
2334 lilv_instance_activate(_impl->instance);
2335 _was_activated = true;
2340 LV2Plugin::deactivate()
2342 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2344 if (_was_activated) {
2345 lilv_instance_deactivate(_impl->instance);
2346 _was_activated = false;
2351 LV2Plugin::cleanup()
2353 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2356 lilv_instance_free(_impl->instance);
2357 _impl->instance = NULL;
2361 LV2Plugin::allocate_atom_event_buffers()
2363 /* reserve local scratch buffers for ATOM event-queues */
2364 const LilvPlugin* p = _impl->plugin;
2366 /* count non-MIDI atom event-ports
2367 * TODO: nicely ask drobilla to make a lilv_ call for that
2369 int count_atom_out = 0;
2370 int count_atom_in = 0;
2371 int minimumSize = 32768; // TODO use a per-port minimum-size
2372 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2373 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2374 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2375 LilvNodes* buffer_types = lilv_port_get_value(
2376 p, port, _world.atom_bufferType);
2377 LilvNodes* atom_supports = lilv_port_get_value(
2378 p, port, _world.atom_supports);
2380 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2381 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2384 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2387 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2388 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2389 if (min_size && lilv_node_is_int(min_size)) {
2390 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2392 lilv_nodes_free(min_size_v);
2394 lilv_nodes_free(buffer_types);
2395 lilv_nodes_free(atom_supports);
2399 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2400 name(), count_atom_in, count_atom_out));
2402 const int total_atom_buffers = (count_atom_in + count_atom_out);
2403 if (_atom_ev_buffers || total_atom_buffers == 0) {
2407 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2408 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2409 for (int i = 0; i < total_atom_buffers; ++i ) {
2410 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2411 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2413 _atom_ev_buffers[total_atom_buffers] = 0;
2417 /** Write an ardour position/time/tempo/meter as an LV2 event.
2418 * @return true on success.
2421 write_position(LV2_Atom_Forge* forge,
2423 const TempoMetric& t,
2424 Timecode::BBT_Time& bbt,
2427 framepos_t position,
2430 const URIMap::URIDs& urids = URIMap::instance().urids;
2432 uint8_t pos_buf[256];
2433 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2434 LV2_Atom_Forge_Frame frame;
2435 #ifdef HAVE_LV2_1_10_0
2436 lv2_atom_forge_object(forge, &frame, 0, urids.time_Position);
2437 lv2_atom_forge_key(forge, urids.time_frame);
2438 lv2_atom_forge_long(forge, position);
2439 lv2_atom_forge_key(forge, urids.time_speed);
2440 lv2_atom_forge_float(forge, speed);
2441 lv2_atom_forge_key(forge, urids.time_barBeat);
2442 lv2_atom_forge_float(forge, bbt.beats - 1 +
2443 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2444 lv2_atom_forge_key(forge, urids.time_bar);
2445 lv2_atom_forge_long(forge, bbt.bars - 1);
2446 lv2_atom_forge_key(forge, urids.time_beatUnit);
2447 lv2_atom_forge_int(forge, t.meter().note_divisor());
2448 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2449 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2450 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2451 lv2_atom_forge_float(forge, bpm);
2453 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2454 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2455 lv2_atom_forge_long(forge, position);
2456 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2457 lv2_atom_forge_float(forge, speed);
2458 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2459 lv2_atom_forge_float(forge, bbt.beats - 1 +
2460 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2461 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2462 lv2_atom_forge_long(forge, bbt.bars - 1);
2463 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2464 lv2_atom_forge_int(forge, t.meter().note_divisor());
2465 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2466 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2467 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2468 lv2_atom_forge_float(forge, bpm);
2471 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2472 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2473 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2474 (const uint8_t*)(atom + 1));
2478 LV2Plugin::connect_and_run(BufferSet& bufs,
2479 framepos_t start, framepos_t end, double speed,
2480 ChanMapping in_map, ChanMapping out_map,
2481 pframes_t nframes, framecnt_t offset)
2483 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2484 Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2486 cycles_t then = get_cycles();
2488 TempoMap& tmap = _session.tempo_map();
2489 Metrics::const_iterator metric_i = tmap.metrics_end();
2490 TempoMetric tmetric = tmap.metric_at(start, &metric_i);
2492 if (_freewheel_control_port) {
2493 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2496 if (_bpm_control_port) {
2497 *_bpm_control_port = tmap.tempo_at_frame (start).note_types_per_minute();
2501 if (_can_write_automation && start != _next_cycle_start) {
2502 // add guard-points after locating
2503 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2504 i->second->guard = true;
2509 ChanCount bufs_count;
2510 bufs_count.set(DataType::AUDIO, 1);
2511 bufs_count.set(DataType::MIDI, 1);
2512 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2513 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2514 uint32_t const num_ports = parameter_count();
2515 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2517 uint32_t audio_in_index = 0;
2518 uint32_t audio_out_index = 0;
2519 uint32_t midi_in_index = 0;
2520 uint32_t midi_out_index = 0;
2521 uint32_t atom_port_index = 0;
2522 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2524 uint32_t index = nil_index;
2525 PortFlags flags = _port_flags[port_index];
2527 if (flags & PORT_AUDIO) {
2528 if (flags & PORT_INPUT) {
2529 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2531 ? bufs.get_audio(index).data(offset)
2532 : silent_bufs.get_audio(0).data(offset);
2534 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2536 ? bufs.get_audio(index).data(offset)
2537 : scratch_bufs.get_audio(0).data(offset);
2539 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2540 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2541 be necessary, but the mapping is illegal in some cases. Ideally
2542 that should be fixed, but this is easier...
2544 if (flags & PORT_MIDI) {
2545 if (flags & PORT_INPUT) {
2546 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2548 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2550 if (valid && bufs.count().n_midi() > index) {
2551 /* Note, ensure_lv2_bufsize() is not RT safe!
2552 * However free()/alloc() is only called if a
2553 * plugin requires a rsz:minimumSize buffersize
2554 * and the existing buffer if smaller.
2556 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2557 _ev_buffers[port_index] = bufs.get_lv2_midi(
2558 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2560 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2561 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2562 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2566 if (valid && (flags & PORT_INPUT)) {
2567 if ((flags & PORT_POSITION)) {
2568 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2569 double bpm = tmap.tempo_at_frame (start).note_types_per_minute();
2570 double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
2572 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2573 beatpos *= tmetric.meter().note_divisor() / 4.0;
2574 if (start != _next_cycle_start ||
2575 speed != _next_cycle_speed ||
2576 rint (1000 * beatpos) != rint(1000 * _next_cycle_beat) ||
2577 bpm != _current_bpm) {
2578 // Transport or Tempo has changed, write position at cycle start
2579 write_position(&_impl->forge, _ev_buffers[port_index],
2580 tmetric, bbt, speed, bpm, start, 0);
2584 // Get MIDI iterator range (empty range if no MIDI)
2585 MidiBuffer::iterator m = (index != nil_index)
2586 ? bufs.get_midi(index).begin()
2587 : silent_bufs.get_midi(0).end();
2588 MidiBuffer::iterator m_end = (index != nil_index)
2589 ? bufs.get_midi(index).end()
2592 // Now merge MIDI and any transport events into the buffer
2593 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2594 const framepos_t tend = end;
2596 while (m != m_end || (metric_i != tmap.metrics_end() &&
2597 (*metric_i)->frame() < tend)) {
2598 MetricSection* metric = (metric_i != tmap.metrics_end())
2600 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2601 const Evoral::Event<framepos_t> ev(*m, false);
2602 if (ev.time() < nframes) {
2603 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2604 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2608 tmetric.set_metric(metric);
2609 Timecode::BBT_Time bbt;
2610 bbt = tmap.bbt_at_frame (metric->frame());
2611 double bpm = tmap.tempo_at_frame (start/*XXX*/).note_types_per_minute();
2612 write_position(&_impl->forge, _ev_buffers[port_index],
2613 tmetric, bbt, speed, bpm,
2615 metric->frame() - start);
2619 } else if (!valid) {
2620 // Nothing we understand or care about, connect to scratch
2621 // see note for midi-buffer size above
2622 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2623 0, _port_minimumSize[port_index]);
2624 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2625 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2628 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2630 continue; // Control port, leave buffer alone
2632 lilv_instance_connect_port(_impl->instance, port_index, buf);
2635 // Read messages from UI and push into appropriate buffers
2637 uint32_t read_space = _from_ui->read_space();
2638 while (read_space > sizeof(UIMessage)) {
2640 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2641 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2644 vector<uint8_t> body(msg.size);
2645 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2646 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2649 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2650 LV2_Evbuf* buf = _ev_buffers[msg.index];
2651 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2652 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2653 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2654 (const uint8_t*)(atom + 1))) {
2655 error << "Failed to write data to LV2 event buffer\n";
2658 error << "Received unknown message type from UI" << endmsg;
2660 read_space -= sizeof(UIMessage) + msg.size;
2667 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2668 PortFlags flags = _port_flags[port_index];
2671 /* TODO ask drobilla about comment
2672 * "Make Ardour event buffers generic so plugins can communicate"
2673 * in libs/ardour/buffer_set.cc:310
2675 * ideally the user could choose which of the following two modes
2676 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2678 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2679 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2680 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2681 * for quite a while at least ;)
2683 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2684 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2685 const uint32_t buf_index = out_map.get(
2686 DataType::MIDI, midi_out_index++, &valid);
2688 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2691 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2692 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2693 const uint32_t buf_index = out_map.get(
2694 DataType::MIDI, midi_out_index++, &valid);
2696 bufs.flush_lv2_midi(true, buf_index);
2700 // Write messages to UI
2701 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2702 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2703 LV2_Evbuf* buf = _ev_buffers[port_index];
2704 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2705 lv2_evbuf_is_valid(i);
2706 i = lv2_evbuf_next(i)) {
2707 uint32_t frames, subframes, type, size;
2709 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2712 // Intercept Automation Write Events
2713 if ((flags & PORT_AUTOCTRL)) {
2714 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2715 if (atom->type == _uri_map.urids.atom_Blank ||
2716 atom->type == _uri_map.urids.atom_Object) {
2717 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2718 if (obj->body.otype == _uri_map.urids.auto_event) {
2719 // only if transport_rolling ??
2720 const LV2_Atom* parameter = NULL;
2721 const LV2_Atom* value = NULL;
2722 lv2_atom_object_get(obj,
2723 _uri_map.urids.auto_parameter, ¶meter,
2724 _uri_map.urids.auto_value, &value,
2726 if (parameter && value) {
2727 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2728 const float v = ((const LV2_Atom_Float*)value)->body;
2729 // -> add automation event..
2730 DEBUG_TRACE(DEBUG::LV2Automate,
2731 string_compose ("Event p: %1 t: %2 v: %3\n", p, frames, v));
2732 AutomationCtrlPtr c = get_automation_control (p);
2734 (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2736 framepos_t when = std::max ((framepos_t) 0, start + frames - _current_latency);
2737 assert (start + frames - _current_latency >= 0);
2740 c->ac->list()->add (when, v, true, true);
2742 c->ac->set_double (v, when, true);
2747 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2748 // TODO optional arguments, for now we assume the plugin
2749 // writes automation for its own inputs
2750 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2751 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2752 if (_port_flags[i->first] & PORT_CTRLED) {
2753 DEBUG_TRACE(DEBUG::LV2Automate,
2754 string_compose ("Setup p: %1\n", i->first));
2755 i->second->ac->set_automation_state (Touch);
2759 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2760 // set [touched] parameters to "play" ??
2761 // allow plugin to change its mode (from analyze to apply)
2762 const LV2_Atom* parameter = NULL;
2763 const LV2_Atom* value = NULL;
2764 lv2_atom_object_get(obj,
2765 _uri_map.urids.auto_parameter, ¶meter,
2766 _uri_map.urids.auto_value, &value,
2768 if (parameter && value) {
2769 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2770 const float v = ((const LV2_Atom_Float*)value)->body;
2771 AutomationCtrlPtr c = get_automation_control (p);
2772 DEBUG_TRACE(DEBUG::LV2Automate,
2773 string_compose ("Finalize p: %1 v: %2\n", p, v));
2774 if (c && _port_flags[p] & PORT_CTRLER) {
2775 c->ac->set_value(v, Controllable::NoGroup);
2778 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2780 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2781 // guard will be false if an event was written
2782 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2783 DEBUG_TRACE(DEBUG::LV2Automate,
2784 string_compose ("Thin p: %1\n", i->first));
2785 i->second->ac->alist ()->thin (20);
2789 else if (obj->body.otype == _uri_map.urids.auto_start) {
2790 const LV2_Atom* parameter = NULL;
2791 lv2_atom_object_get(obj,
2792 _uri_map.urids.auto_parameter, ¶meter,
2795 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2796 AutomationCtrlPtr c = get_automation_control (p);
2797 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2799 c->ac->start_touch (std::max ((framepos_t)0, start - _current_latency));
2804 else if (obj->body.otype == _uri_map.urids.auto_end) {
2805 const LV2_Atom* parameter = NULL;
2806 lv2_atom_object_get(obj,
2807 _uri_map.urids.auto_parameter, ¶meter,
2810 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2811 AutomationCtrlPtr c = get_automation_control (p);
2812 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2814 c->ac->stop_touch (true, std::max ((framepos_t)0, start - _current_latency));
2821 // Intercept state dirty message
2822 if (_has_state_interface /* && (flags & PORT_DIRTYMSG)*/) {
2823 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2824 if (atom->type == _uri_map.urids.atom_Blank ||
2825 atom->type == _uri_map.urids.atom_Object) {
2826 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2827 if (obj->body.otype == _uri_map.urids.state_StateChanged) {
2828 _session.set_dirty ();
2833 // Intercept patch change messages to emit PropertyChanged signal
2834 if ((flags & PORT_PATCHMSG)) {
2835 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2836 if (atom->type == _uri_map.urids.atom_Blank ||
2837 atom->type == _uri_map.urids.atom_Object) {
2838 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2839 if (obj->body.otype == _uri_map.urids.patch_Set) {
2840 const LV2_Atom* property = NULL;
2841 const LV2_Atom* value = NULL;
2842 lv2_atom_object_get(obj,
2843 _uri_map.urids.patch_property, &property,
2844 _uri_map.urids.patch_value, &value,
2847 if (property && value &&
2848 property->type == _uri_map.urids.atom_URID &&
2849 value->type == _uri_map.urids.atom_Path) {
2850 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2851 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2853 // Emit PropertyChanged signal for UI
2854 // TODO: This should emit the control's Changed signal
2855 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2857 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2863 if (!_to_ui) continue;
2864 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2865 size + sizeof(LV2_Atom),
2866 data - sizeof(LV2_Atom));
2871 cycles_t now = get_cycles();
2872 set_cycles((uint32_t)(now - then));
2874 // Update expected transport information for next cycle so we can detect changes
2875 _next_cycle_speed = speed;
2876 _next_cycle_start = end;
2879 /* keep track of lv2:timePosition like plugins can do.
2880 * Note: for no-midi plugins, we only ever send information at cycle-start,
2881 * so it needs to be realative to that.
2883 TempoMetric t = tmap.metric_at(start);
2884 _current_bpm = tmap.tempo_at_frame (start).note_types_per_minute();
2885 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2886 double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
2888 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2889 beatpos *= tmetric.meter().note_divisor() / 4.0;
2890 _next_cycle_beat = beatpos + nframes * speed * _current_bpm / (60.f * _session.frame_rate());
2893 if (_latency_control_port) {
2894 framecnt_t new_latency = signal_latency ();
2895 _current_latency = new_latency;
2901 LV2Plugin::parameter_is_control(uint32_t param) const
2903 assert(param < _port_flags.size());
2904 return _port_flags[param] & PORT_CONTROL;
2908 LV2Plugin::parameter_is_audio(uint32_t param) const
2910 assert(param < _port_flags.size());
2911 return _port_flags[param] & PORT_AUDIO;
2915 LV2Plugin::parameter_is_event(uint32_t param) const
2917 assert(param < _port_flags.size());
2918 return _port_flags[param] & PORT_EVENT;
2922 LV2Plugin::parameter_is_output(uint32_t param) const
2924 assert(param < _port_flags.size());
2925 return _port_flags[param] & PORT_OUTPUT;
2929 LV2Plugin::parameter_is_input(uint32_t param) const
2931 assert(param < _port_flags.size());
2932 return _port_flags[param] & PORT_INPUT;
2936 LV2Plugin::designated_bypass_port ()
2938 const LilvPort* port = NULL;
2939 LilvNode* designation = lilv_new_uri (_world.world, LV2_CORE_PREFIX "enabled");
2940 port = lilv_plugin_get_port_by_designation (
2941 _impl->plugin, _world.lv2_InputPort, designation);
2942 lilv_node_free(designation);
2944 return lilv_port_get_index (_impl->plugin, port);
2947 /* deprecated on 2016-Sep-18 in favor of lv2:enabled */
2948 designation = lilv_new_uri (_world.world, LV2_PROCESSING_URI__enable);
2949 port = lilv_plugin_get_port_by_designation (
2950 _impl->plugin, _world.lv2_InputPort, designation);
2951 lilv_node_free(designation);
2953 return lilv_port_get_index (_impl->plugin, port);
2960 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2963 if (param < parameter_count()) {
2964 snprintf(buf, len, "%.3f", get_parameter(param));
2971 boost::shared_ptr<ScalePoints>
2972 LV2Plugin::get_scale_points(uint32_t port_index) const
2974 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2975 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2977 boost::shared_ptr<ScalePoints> ret;
2982 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2984 LILV_FOREACH(scale_points, i, points) {
2985 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2986 const LilvNode* label = lilv_scale_point_get_label(p);
2987 const LilvNode* value = lilv_scale_point_get_value(p);
2988 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2989 ret->insert(make_pair(lilv_node_as_string(label),
2990 lilv_node_as_float(value)));
2994 lilv_scale_points_free(points);
2999 LV2Plugin::run(pframes_t nframes, bool sync_work)
3001 uint32_t const N = parameter_count();
3002 for (uint32_t i = 0; i < N; ++i) {
3003 if (parameter_is_control(i) && parameter_is_input(i)) {
3004 _control_data[i] = _shadow_data[i];
3009 // Execute work synchronously if we're freewheeling (export)
3010 _worker->set_synchronous(sync_work || session().engine().freewheeling());
3013 // Run the plugin for this cycle
3014 lilv_instance_run(_impl->instance, nframes);
3016 // Emit any queued worker responses (calls a plugin callback)
3017 if (_state_worker) {
3018 _state_worker->emit_responses();
3021 _worker->emit_responses();
3024 // Notify the plugin that a work run cycle is complete
3025 if (_impl->work_iface) {
3026 if (_impl->work_iface->end_run) {
3027 _impl->work_iface->end_run(_impl->instance->lv2_handle);
3033 LV2Plugin::latency_compute_run()
3035 if (!_latency_control_port) {
3039 // Run the plugin so that it can set its latency parameter
3041 bool was_activated = _was_activated;
3044 uint32_t port_index = 0;
3045 uint32_t in_index = 0;
3046 uint32_t out_index = 0;
3048 // this is done in the main thread. non realtime.
3049 const framecnt_t bufsize = _engine.samples_per_cycle();
3050 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
3052 memset(buffer, 0, sizeof(float) * bufsize);
3054 // FIXME: Ensure plugins can handle in-place processing
3058 while (port_index < parameter_count()) {
3059 if (parameter_is_audio(port_index)) {
3060 if (parameter_is_input(port_index)) {
3061 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3063 } else if (parameter_is_output(port_index)) {
3064 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3073 if (was_activated) {
3080 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
3082 const LilvPort* port = NULL;
3083 LilvNode* designation = lilv_new_uri(_world.world, uri);
3084 port = lilv_plugin_get_port_by_designation(
3085 plugin, _world.lv2_InputPort, designation);
3086 lilv_node_free(designation);
3088 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
3093 static bool lv2_filter (const string& str, void* /*arg*/)
3095 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
3097 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
3101 LV2World::LV2World()
3102 : world(lilv_world_new())
3103 , _bundle_checked(false)
3105 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
3106 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
3107 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
3108 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
3109 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
3110 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
3111 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
3112 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
3113 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
3114 ext_expensive = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
3115 ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
3116 ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
3117 ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
3118 groups_group = lilv_new_uri(world, LV2_PORT_GROUPS__group);
3119 groups_element = lilv_new_uri(world, LV2_PORT_GROUPS__element);
3120 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
3121 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
3122 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
3123 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
3124 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
3125 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
3126 lv2_index = lilv_new_uri(world, LV2_CORE__index);
3127 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
3128 lv2_default = lilv_new_uri(world, LV2_CORE__default);
3129 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
3130 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
3131 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
3132 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
3133 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
3134 lv2_designation = lilv_new_uri(world, LV2_CORE__designation);
3135 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
3136 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
3137 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
3138 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
3139 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
3140 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
3141 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
3142 time_Position = lilv_new_uri(world, LV2_TIME__Position);
3143 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
3144 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
3145 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
3146 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
3147 units_render = lilv_new_uri(world, LV2_UNITS__render);
3148 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
3149 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
3150 units_db = lilv_new_uri(world, LV2_UNITS__db);
3151 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
3152 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
3154 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls"); // deprecated 2016-09-18
3155 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
3156 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
3157 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
3158 auto_automation_controller = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
3160 #ifdef HAVE_LV2_1_2_0
3161 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
3162 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
3163 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
3164 bufz_coarseBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#coarseBlockLength");
3169 LV2World::~LV2World()
3174 #ifdef HAVE_LV2_1_2_0
3175 lilv_node_free(bufz_coarseBlockLength);
3176 lilv_node_free(bufz_nominalBlockLength);
3177 lilv_node_free(bufz_fixedBlockLength);
3178 lilv_node_free(bufz_powerOf2BlockLength);
3181 lilv_node_free(lv2_noSampleAccurateCtrl);
3182 lilv_node_free(auto_can_write_automatation);
3183 lilv_node_free(auto_automation_control);
3184 lilv_node_free(auto_automation_controlled);
3185 lilv_node_free(auto_automation_controller);
3187 lilv_node_free(patch_Message);
3188 lilv_node_free(patch_writable);
3189 lilv_node_free(units_hz);
3190 lilv_node_free(units_midiNote);
3191 lilv_node_free(units_db);
3192 lilv_node_free(units_unit);
3193 lilv_node_free(units_render);
3194 lilv_node_free(ui_externalkx);
3195 lilv_node_free(ui_external);
3196 lilv_node_free(ui_GtkUI);
3197 lilv_node_free(time_Position);
3198 lilv_node_free(rsz_minimumSize);
3199 lilv_node_free(rdfs_comment);
3200 lilv_node_free(rdfs_label);
3201 lilv_node_free(rdfs_range);
3202 lilv_node_free(midi_MidiEvent);
3203 lilv_node_free(lv2_designation);
3204 lilv_node_free(lv2_enumeration);
3205 lilv_node_free(lv2_freewheeling);
3206 lilv_node_free(lv2_toggled);
3207 lilv_node_free(lv2_sampleRate);
3208 lilv_node_free(lv2_reportsLatency);
3209 lilv_node_free(lv2_index);
3210 lilv_node_free(lv2_integer);
3211 lilv_node_free(lv2_isSideChain);
3212 lilv_node_free(lv2_inPlaceBroken);
3213 lilv_node_free(lv2_OutputPort);
3214 lilv_node_free(lv2_InputPort);
3215 lilv_node_free(lv2_ControlPort);
3216 lilv_node_free(lv2_AudioPort);
3217 lilv_node_free(groups_group);
3218 lilv_node_free(groups_element);
3219 lilv_node_free(ext_rangeSteps);
3220 lilv_node_free(ext_notAutomatic);
3221 lilv_node_free(ext_causesArtifacts);
3222 lilv_node_free(ext_expensive);
3223 lilv_node_free(ext_notOnGUI);
3224 lilv_node_free(ext_logarithmic);
3225 lilv_node_free(ev_EventPort);
3226 lilv_node_free(atom_supports);
3227 lilv_node_free(atom_eventTransfer);
3228 lilv_node_free(atom_bufferType);
3229 lilv_node_free(atom_Sequence);
3230 lilv_node_free(atom_Chunk);
3231 lilv_node_free(atom_AtomPort);
3232 lilv_world_free(world);
3237 LV2World::load_bundled_plugins(bool verbose)
3239 if (!_bundle_checked) {
3241 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
3244 vector<string> plugin_objects;
3245 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
3246 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
3247 #ifdef PLATFORM_WINDOWS
3248 string uri = "file:///" + *x + "/";
3250 string uri = "file://" + *x + "/";
3252 LilvNode *node = lilv_new_uri(world, uri.c_str());
3253 lilv_world_load_bundle(world, node);
3254 lilv_node_free(node);
3257 lilv_world_load_all(world);
3258 _bundle_checked = true;
3262 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
3265 _plugin_uri = strdup(plugin_uri);
3268 LV2PluginInfo::~LV2PluginInfo()
3275 LV2PluginInfo::load(Session& session)
3279 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3280 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3281 if (!uri) { throw failed_constructor(); }
3282 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3283 if (!lp) { throw failed_constructor(); }
3284 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
3285 lilv_node_free(uri);
3286 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3288 } catch (failed_constructor& err) {
3289 return PluginPtr((Plugin*)0);
3295 std::vector<Plugin::PresetRecord>
3296 LV2PluginInfo::get_presets (bool /*user_only*/) const
3298 std::vector<Plugin::PresetRecord> p;
3299 #ifndef NO_PLUGIN_STATE
3300 const LilvPlugin* lp = NULL;
3303 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3304 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3305 if (!uri) { throw failed_constructor(); }
3306 lp = lilv_plugins_get_by_uri(plugins, uri);
3307 if (!lp) { throw failed_constructor(); }
3308 lilv_node_free(uri);
3309 } catch (failed_constructor& err) {
3313 // see LV2Plugin::find_presets
3314 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3315 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3316 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3318 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3319 LILV_FOREACH(nodes, i, presets) {
3320 const LilvNode* preset = lilv_nodes_get(presets, i);
3321 lilv_world_load_resource(_world.world, preset);
3322 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3323 bool userpreset = true; // TODO
3325 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
3326 lilv_node_free(name);
3329 lilv_nodes_free(presets);
3330 lilv_node_free(rdfs_label);
3331 lilv_node_free(pset_Preset);
3332 lilv_node_free(lv2_appliesTo);
3338 LV2PluginInfo::in_category (const std::string &c) const
3340 // TODO use untranslated lilv_plugin_get_class()
3341 // match gtk2_ardour/plugin_selector.cc
3342 return category == c;
3346 LV2PluginInfo::is_instrument () const
3348 if (category == "Instrument") {
3352 /* until we make sure that category remains untranslated in the lv2.ttl spec
3353 * and until most instruments also classify themselves as such, there's a 2nd check:
3355 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
3363 LV2PluginInfo::discover()
3366 world.load_bundled_plugins();
3367 _world.load_bundled_plugins(true);
3369 PluginInfoList* plugs = new PluginInfoList;
3370 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3372 LILV_FOREACH(plugins, i, plugins) {
3373 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3374 const LilvNode* pun = lilv_plugin_get_uri(p);
3376 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3378 LilvNode* name = lilv_plugin_get_name(p);
3379 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3380 warning << "Ignoring invalid LV2 plugin "
3381 << lilv_node_as_string(lilv_plugin_get_uri(p))
3386 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3387 warning << string_compose(
3388 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3389 lilv_node_as_string(name)) << endmsg;
3390 lilv_node_free(name);
3394 #ifdef HAVE_LV2_1_2_0
3395 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3396 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3397 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3399 warning << string_compose(
3400 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3401 lilv_node_as_string(name)) << endmsg;
3402 lilv_nodes_free(required_features);
3403 lilv_node_free(name);
3406 lilv_nodes_free(required_features);
3411 info->name = string(lilv_node_as_string(name));
3412 lilv_node_free(name);
3413 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3415 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3416 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3417 info->category = lilv_node_as_string(label);
3419 LilvNode* author_name = lilv_plugin_get_author_name(p);
3420 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3421 lilv_node_free(author_name);
3423 info->path = "/NOPATH"; // Meaningless for LV2
3425 /* count atom-event-ports that feature
3426 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3428 * TODO: nicely ask drobilla to make a lilv_ call for that
3430 int count_midi_out = 0;
3431 int count_midi_in = 0;
3432 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3433 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3434 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3435 LilvNodes* buffer_types = lilv_port_get_value(
3436 p, port, world.atom_bufferType);
3437 LilvNodes* atom_supports = lilv_port_get_value(
3438 p, port, world.atom_supports);
3440 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3441 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3442 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3445 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3449 lilv_nodes_free(buffer_types);
3450 lilv_nodes_free(atom_supports);
3454 info->n_inputs.set_audio(
3455 lilv_plugin_get_num_ports_of_class(
3456 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3457 info->n_inputs.set_midi(
3458 lilv_plugin_get_num_ports_of_class(
3459 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3462 info->n_outputs.set_audio(
3463 lilv_plugin_get_num_ports_of_class(
3464 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3465 info->n_outputs.set_midi(
3466 lilv_plugin_get_num_ports_of_class(
3467 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3470 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3471 info->index = 0; // Meaningless for LV2
3473 plugs->push_back(info);