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/replace_all.h"
40 #include "pbd/xml++.h"
42 #include "libardour-config.h"
44 #include "ardour/audio_buffer.h"
45 #include "ardour/audioengine.h"
46 #include "ardour/debug.h"
47 #include "ardour/lv2_plugin.h"
48 #include "ardour/midi_patch_manager.h"
49 #include "ardour/session.h"
50 #include "ardour/tempo.h"
51 #include "ardour/types.h"
52 #include "ardour/utils.h"
53 #include "ardour/worker.h"
54 #include "ardour/search_paths.h"
59 #include <lilv/lilv.h>
61 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
62 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
63 #include "lv2/lv2plug.in/ns/ext/log/log.h"
64 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
65 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
66 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
67 #include "lv2/lv2plug.in/ns/ext/state/state.h"
68 #include "lv2/lv2plug.in/ns/ext/time/time.h"
69 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
70 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
71 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
72 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
73 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
75 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
76 #include "lv2/lv2plug.in/ns/ext/options/options.h"
79 #include "lv2_evbuf.h"
82 #include <suil/suil.h>
85 // Compatibility for old LV2
86 #ifndef LV2_ATOM_CONTENTS_CONST
87 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
88 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
90 #ifndef LV2_ATOM_BODY_CONST
91 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
93 #ifndef LV2_PATCH__property
94 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
96 #ifndef LV2_PATCH__value
97 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
99 #ifndef LV2_PATCH__writable
100 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
103 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
104 This needs to be roughly the number of cycles the UI will get around to
105 actually processing the traffic. Lower values are flakier but save memory.
107 static const size_t NBUFS = 4;
110 using namespace ARDOUR;
113 bool LV2Plugin::force_state_save = false;
115 class LV2World : boost::noncopyable {
120 void load_bundled_plugins(bool verbose=false);
124 LilvNode* atom_AtomPort;
125 LilvNode* atom_Chunk;
126 LilvNode* atom_Sequence;
127 LilvNode* atom_bufferType;
128 LilvNode* atom_eventTransfer;
129 LilvNode* atom_supports;
130 LilvNode* ev_EventPort;
131 LilvNode* ext_logarithmic;
132 LilvNode* ext_notOnGUI;
133 LilvNode* ext_expensive;
134 LilvNode* ext_causesArtifacts;
135 LilvNode* ext_notAutomatic;
136 LilvNode* ext_rangeSteps;
137 LilvNode* lv2_AudioPort;
138 LilvNode* lv2_ControlPort;
139 LilvNode* lv2_InputPort;
140 LilvNode* lv2_OutputPort;
141 LilvNode* lv2_enumeration;
142 LilvNode* lv2_freewheeling;
143 LilvNode* lv2_inPlaceBroken;
144 LilvNode* lv2_isSideChain;
145 LilvNode* lv2_integer;
146 LilvNode* lv2_default;
147 LilvNode* lv2_minimum;
148 LilvNode* lv2_maximum;
149 LilvNode* lv2_reportsLatency;
150 LilvNode* lv2_sampleRate;
151 LilvNode* lv2_toggled;
152 LilvNode* midi_MidiEvent;
153 LilvNode* rdfs_comment;
154 LilvNode* rdfs_label;
155 LilvNode* rdfs_range;
156 LilvNode* rsz_minimumSize;
157 LilvNode* time_Position;
159 LilvNode* ui_external;
160 LilvNode* ui_externalkx;
163 LilvNode* units_unit;
164 LilvNode* units_render;
165 LilvNode* units_midiNote;
166 LilvNode* patch_writable;
167 LilvNode* patch_Message;
168 #ifdef HAVE_LV2_1_2_0
169 LilvNode* bufz_powerOf2BlockLength;
170 LilvNode* bufz_fixedBlockLength;
171 LilvNode* bufz_nominalBlockLength;
172 LilvNode* bufz_coarseBlockLength;
175 #ifdef HAVE_LV2_1_10_0
177 LilvNode* atom_float;
178 LilvNode* atom_object; // new in 1.8
179 LilvNode* atom_vector;
182 LilvNode* lv2_noSampleAccurateCtrl;
183 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
184 LilvNode* auto_automation_control; // atom:supports
185 LilvNode* auto_automation_controlled; // lv2:portProperty
186 LilvNode* auto_automation_controller; // lv2:portProperty
190 bool _bundle_checked;
193 static LV2World _world;
195 /* worker extension */
197 /** Called by the plugin to schedule non-RT work. */
198 static LV2_Worker_Status
199 work_schedule(LV2_Worker_Schedule_Handle handle,
203 return (((Worker*)handle)->schedule(size, data)
205 : LV2_WORKER_ERR_UNKNOWN);
208 /** Called by the plugin to respond to non-RT work. */
209 static LV2_Worker_Status
210 work_respond(LV2_Worker_Respond_Handle handle,
214 return (((Worker*)handle)->respond(size, data)
216 : LV2_WORKER_ERR_UNKNOWN);
220 /* inline display extension */
222 queue_draw (LV2_Inline_Display_Handle handle)
224 LV2Plugin* plugin = (LV2Plugin*)handle;
225 plugin->QueueDraw(); /* EMIT SIGNAL */
229 midnam_update (LV2_Midnam_Handle handle)
231 LV2Plugin* plugin = (LV2Plugin*)handle;
232 plugin->UpdateMidnam (); /* EMIT SIGNAL */
239 log_vprintf(LV2_Log_Handle /*handle*/,
245 const int ret = g_vasprintf(&str, fmt, args);
246 /* strip trailing whitespace */
247 while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
248 str[strlen (str) - 1] = '\0';
250 if (strlen (str) == 0) {
254 if (type == URIMap::instance().urids.log_Error) {
255 error << str << endmsg;
256 } else if (type == URIMap::instance().urids.log_Warning) {
257 warning << str << endmsg;
258 } else if (type == URIMap::instance().urids.log_Note) {
259 info << str << endmsg;
260 } else if (type == URIMap::instance().urids.log_Trace) {
261 DEBUG_TRACE(DEBUG::LV2, str);
267 log_printf(LV2_Log_Handle handle,
269 const char* fmt, ...)
273 const int ret = log_vprintf(handle, type, fmt, args);
278 struct LV2Plugin::Impl {
279 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
281 #ifdef HAVE_LV2_1_2_0
286 #ifdef HAVE_LV2_1_2_0
295 /** Find the LV2 input port with the given designation.
296 * If found, bufptrs[port_index] will be set to bufptr.
298 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
300 const LilvPlugin* plugin;
302 const LilvNode* ui_type;
305 LilvInstance* instance;
306 const LV2_Worker_Interface* work_iface;
307 #ifdef HAVE_LV2_1_2_0
308 const LV2_Options_Interface* opts_iface;
311 LV2_Atom_Forge forge;
312 LV2_Atom_Forge ui_forge;
313 int32_t block_length;
314 #ifdef HAVE_LV2_1_2_0
315 LV2_Options_Option* options;
318 LV2_Inline_Display* queue_draw;
323 LV2Plugin::LV2Plugin (AudioEngine& engine,
325 const void* c_plugin,
327 : Plugin (engine, session)
332 , _state_worker(NULL)
334 , _patch_port_in_index((uint32_t)-1)
335 , _patch_port_out_index((uint32_t)-1)
336 , _uri_map(URIMap::instance())
337 , _no_sample_accurate_ctrl (false)
339 init(c_plugin, rate);
342 LV2Plugin::LV2Plugin (const LV2Plugin& other)
348 , _state_worker(NULL)
349 , _insert_id(other._insert_id)
350 , _patch_port_in_index((uint32_t)-1)
351 , _patch_port_out_index((uint32_t)-1)
352 , _uri_map(URIMap::instance())
353 , _no_sample_accurate_ctrl (false)
355 init(other._impl->plugin, other._sample_rate);
357 for (uint32_t i = 0; i < parameter_count(); ++i) {
358 _control_data[i] = other._shadow_data[i];
359 _shadow_data[i] = other._shadow_data[i];
364 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
366 DEBUG_TRACE(DEBUG::LV2, "init\n");
368 _impl->plugin = (const LilvPlugin*)c_plugin;
370 _impl->ui_type = NULL;
375 _atom_ev_buffers = 0;
377 _bpm_control_port = 0;
378 _freewheel_control_port = 0;
379 _latency_control_port = 0;
380 _next_cycle_start = std::numeric_limits<framepos_t>::max();
381 _next_cycle_speed = 1.0;
382 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
384 _was_activated = false;
385 _has_state_interface = false;
386 _can_write_automation = false;
388 _current_latency = 0;
389 _impl->block_length = _session.get_block_size();
391 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
392 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
393 _make_path_feature.URI = LV2_STATE__makePath;
394 _log_feature.URI = LV2_LOG__log;
395 _work_schedule_feature.URI = LV2_WORKER__schedule;
396 _work_schedule_feature.data = NULL;
397 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
398 _def_state_feature.data = NULL;
400 const LilvPlugin* plugin = _impl->plugin;
402 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
403 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
404 _has_state_interface =
405 // What plugins should have (lv2:extensionData state:Interface)
406 lilv_plugin_has_extension_data(plugin, state_iface_uri)
407 // What some outdated/incorrect ones have
408 || lilv_plugin_has_feature(plugin, state_uri);
409 lilv_node_free(state_uri);
410 lilv_node_free(state_iface_uri);
412 _features = (LV2_Feature**)calloc(13, sizeof(LV2_Feature*));
413 _features[0] = &_instance_access_feature;
414 _features[1] = &_data_access_feature;
415 _features[2] = &_make_path_feature;
416 _features[3] = _uri_map.uri_map_feature();
417 _features[4] = _uri_map.urid_map_feature();
418 _features[5] = _uri_map.urid_unmap_feature();
419 _features[6] = &_log_feature;
421 unsigned n_features = 7;
422 #ifdef HAVE_LV2_1_2_0
423 _features[n_features++] = &_def_state_feature;
426 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
427 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
430 _impl->queue_draw = (LV2_Inline_Display*)
431 malloc (sizeof(LV2_Inline_Display));
432 _impl->queue_draw->handle = this;
433 _impl->queue_draw->queue_draw = queue_draw;
435 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
436 _queue_draw_feature.data = _impl->queue_draw;
437 _features[n_features++] = &_queue_draw_feature;
439 _impl->midnam = (LV2_Midnam*)
440 malloc (sizeof(LV2_Midnam));
441 _impl->midnam->handle = this;
442 _impl->midnam->update = midnam_update;
444 _midnam_feature.URI = LV2_MIDNAM__update;
445 _midnam_feature.data = _impl->midnam;
446 _features[n_features++] = &_midnam_feature;
449 #ifdef HAVE_LV2_1_2_0
450 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
451 static const int32_t _min_block_length = 1; // may happen during split-cycles
452 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
453 /* Consider updating max-block-size whenever the buffersize changes.
454 * It requires re-instantiating the plugin (which is a non-realtime operation),
455 * so it should be done lightly and only for plugins that require it.
457 * given that the block-size can change at any time (split-cycles) ardour currently
458 * does not support plugins that require bufz_fixedBlockLength.
460 LV2_Options_Option options[] = {
461 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
462 sizeof(int32_t), atom_Int, &_min_block_length },
463 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
464 sizeof(int32_t), atom_Int, &_max_block_length },
465 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
466 sizeof(int32_t), atom_Int, &_seq_size },
467 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
468 sizeof(int32_t), atom_Int, &_impl->block_length },
469 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
472 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
473 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
475 _options_feature.URI = LV2_OPTIONS__options;
476 _options_feature.data = _impl->options;
477 _features[n_features++] = &_options_feature;
480 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
481 sizeof(LV2_State_Make_Path));
482 make_path->handle = this;
483 make_path->path = &lv2_state_make_path;
484 _make_path_feature.data = make_path;
486 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
488 log->printf = &log_printf;
489 log->vprintf = &log_vprintf;
490 _log_feature.data = log;
492 const size_t ring_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
493 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
494 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
495 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
496 sizeof(LV2_Worker_Schedule));
497 _worker = new Worker(this, ring_size);
498 schedule->handle = _worker;
499 schedule->schedule_work = work_schedule;
500 _work_schedule_feature.data = schedule;
501 _features[n_features++] = &_work_schedule_feature;
503 lilv_node_free(worker_schedule);
505 if (_has_state_interface) {
506 // Create a non-threaded worker for use by state restore
507 _state_worker = new Worker(this, ring_size, false);
510 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
511 _impl->name = lilv_plugin_get_name(plugin);
512 _impl->author = lilv_plugin_get_author_name(plugin);
514 if (_impl->instance == 0) {
515 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
516 throw failed_constructor();
519 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
520 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
521 _data_access_feature.data = &_data_access_extension_data;
523 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
524 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
525 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
526 LV2_WORKER__interface);
528 lilv_node_free(worker_iface_uri);
531 #ifdef HAVE_LV2_1_2_0
532 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
533 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
534 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
535 LV2_OPTIONS__interface);
537 lilv_node_free(options_iface_uri);
541 _display_interface = (const LV2_Inline_Display_Interface*)
542 extension_data (LV2_INLINEDISPLAY__interface);
544 _midname_interface = (const LV2_Midnam_Interface*)
545 extension_data (LV2_MIDNAM__interface);
546 if (_midname_interface) {
551 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
552 error << string_compose(
553 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
554 lilv_node_as_string(_impl->name)) << endmsg;
555 lilv_node_free(_impl->name);
556 lilv_node_free(_impl->author);
557 throw failed_constructor();
560 #ifdef HAVE_LV2_1_2_0
561 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
562 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
563 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
565 error << string_compose(
566 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
567 lilv_node_as_string(_impl->name)) << endmsg;
568 lilv_node_free(_impl->name);
569 lilv_node_free(_impl->author);
570 lilv_nodes_free(required_features);
571 throw failed_constructor();
573 lilv_nodes_free(required_features);
576 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
577 #ifdef HAVE_LV2_1_2_0
578 if (lilv_nodes_contains (optional_features, _world.bufz_coarseBlockLength)) {
579 _no_sample_accurate_ctrl = true;
583 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
584 /* deprecated 2016-Sep-18 in favor of bufz_coarseBlockLength */
585 _no_sample_accurate_ctrl = true;
587 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
588 _can_write_automation = true;
590 lilv_nodes_free(optional_features);
593 #ifdef HAVE_LILV_0_16_0
594 // Load default state
596 /* immediately schedule any work,
597 * so that state restore later will not find a busy
598 * worker. latency_compute_run() flushes any replies
600 _worker->set_synchronous(true);
602 LilvState* state = lilv_state_new_from_world(
603 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
604 if (state && _has_state_interface) {
605 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
607 lilv_state_free(state);
612 const uint32_t num_ports = this->num_ports();
613 for (uint32_t i = 0; i < num_ports; ++i) {
614 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
616 size_t minimumSize = 0;
618 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
619 flags |= PORT_OUTPUT;
620 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
623 error << string_compose(
624 "LV2: \"%1\" port %2 is neither input nor output",
625 lilv_node_as_string(_impl->name), i) << endmsg;
626 throw failed_constructor();
629 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
630 flags |= PORT_CONTROL;
631 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
633 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
635 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
636 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
637 LilvNodes* buffer_types = lilv_port_get_value(
638 _impl->plugin, port, _world.atom_bufferType);
639 LilvNodes* atom_supports = lilv_port_get_value(
640 _impl->plugin, port, _world.atom_supports);
642 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
643 flags |= PORT_SEQUENCE;
644 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
647 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
648 flags |= PORT_POSITION;
651 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
652 flags |= PORT_AUTOCTRL;
655 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
656 flags |= PORT_PATCHMSG;
657 if (flags & PORT_INPUT) {
658 _patch_port_in_index = i;
660 _patch_port_out_index = i;
664 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
665 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
666 if (min_size && lilv_node_is_int(min_size)) {
667 minimumSize = lilv_node_as_int(min_size);
669 lilv_nodes_free(min_size_v);
670 lilv_nodes_free(buffer_types);
671 lilv_nodes_free(atom_supports);
673 error << string_compose(
674 "LV2: \"%1\" port %2 has no known data type",
675 lilv_node_as_string(_impl->name), i) << endmsg;
676 throw failed_constructor();
679 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
680 if (lilv_port_has_property(_impl->plugin, port, _world.ext_causesArtifacts)) {
681 flags |= PORT_NOAUTO;
683 if (lilv_port_has_property(_impl->plugin, port, _world.ext_notAutomatic)) {
684 flags |= PORT_NOAUTO;
686 if (lilv_port_has_property(_impl->plugin, port, _world.ext_expensive)) {
687 flags |= PORT_NOAUTO;
691 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
692 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
693 flags |= PORT_CTRLED;
696 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controller)) {
697 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
698 flags |= PORT_CTRLER;
703 _port_flags.push_back(flags);
704 _port_minimumSize.push_back(minimumSize);
705 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
708 _control_data = new float[num_ports];
709 _shadow_data = new float[num_ports];
710 _defaults = new float[num_ports];
711 _ev_buffers = new LV2_Evbuf*[num_ports];
712 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
714 const bool latent = lilv_plugin_has_latency(plugin);
715 const uint32_t latency_index = (latent)
716 ? lilv_plugin_get_latency_port_index(plugin)
719 // Build an array of pointers to special parameter buffers
720 void*** params = new void**[num_ports];
721 for (uint32_t i = 0; i < num_ports; ++i) {
724 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
725 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
727 for (uint32_t i = 0; i < num_ports; ++i) {
728 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
729 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
731 // Store index in map so we can look up index by symbol
732 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
734 // Get range and default value if applicable
735 if (parameter_is_control(i)) {
737 lilv_port_get_range(plugin, port, &def, NULL, NULL);
738 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
739 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
740 _defaults[i] *= _session.frame_rate ();
744 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
746 if (latent && i == latency_index) {
748 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
749 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
750 _latency_control_port = &_control_data[i];
751 *_latency_control_port = 0;
754 if (parameter_is_input(i)) {
755 _shadow_data[i] = default_value(i);
757 *params[i] = (void*)&_shadow_data[i];
767 LilvUIs* uis = lilv_plugin_get_uis(plugin);
768 if (lilv_uis_size(uis) > 0) {
770 // Look for embeddable UI
771 LILV_FOREACH(uis, u, uis) {
772 const LilvUI* this_ui = lilv_uis_get(uis, u);
773 const LilvNode* this_ui_type = NULL;
774 if (lilv_ui_is_supported(this_ui,
778 // TODO: Multiple UI support
780 _impl->ui_type = this_ui_type;
785 // Look for Gtk native UI
786 LILV_FOREACH(uis, i, uis) {
787 const LilvUI* ui = lilv_uis_get(uis, i);
788 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
790 _impl->ui_type = _world.ui_GtkUI;
796 // If Gtk UI is not available, try to find external UI
798 LILV_FOREACH(uis, i, uis) {
799 const LilvUI* ui = lilv_uis_get(uis, i);
800 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
802 _impl->ui_type = _world.ui_external;
805 if (lilv_ui_is_a(ui, _world.ui_external)) {
807 _impl->ui_type = _world.ui_external;
813 load_supported_properties(_property_descriptors);
814 allocate_atom_event_buffers();
815 latency_compute_run();
819 LV2Plugin::set_block_size (pframes_t nframes)
821 #ifdef HAVE_LV2_1_2_0
822 if (_impl->opts_iface) {
823 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
824 _impl->block_length = nframes;
825 LV2_Options_Option block_size_option = {
826 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
827 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
829 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
836 LV2Plugin::requires_fixed_sized_buffers () const
838 /* This controls if Ardour will split the plugin's run()
839 * on automation events in order to pass sample-accurate automation
840 * via standard control-ports.
842 * When returning true Ardour will *not* sub-divide the process-cycle.
843 * Automation events that happen between cycle-start and cycle-end will be
844 * ignored (ctrl values are interpolated to cycle-start).
845 * NB. Atom Sequences are still sample accurate.
847 * Note: This does not guarantee a fixed block-size.
848 * e.g The process cycle may be split when looping, also
849 * the period-size may change any time: see set_block_size()
851 if (get_info()->n_inputs.n_midi() > 0) {
852 /* we don't yet implement midi buffer offsets (for split cycles).
853 * Also connect_and_run() also uses _session.transport_frame() directly
854 * (for BBT) which is not offset for plugin cycle split.
858 return _no_sample_accurate_ctrl;
861 LV2Plugin::~LV2Plugin ()
863 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
870 std::stringstream ss;
873 MIDI::Name::MidiPatchManager::instance().remove_custom_midnam (ss.str());
877 lilv_instance_free(_impl->instance);
878 lilv_state_free(_impl->state);
879 lilv_node_free(_impl->name);
880 lilv_node_free(_impl->author);
881 #ifdef HAVE_LV2_1_2_0
882 free(_impl->options);
885 free(_impl->queue_draw);
890 free(_log_feature.data);
891 free(_make_path_feature.data);
892 free(_work_schedule_feature.data);
897 delete _state_worker;
899 if (_atom_ev_buffers) {
900 LV2_Evbuf** b = _atom_ev_buffers;
905 free(_atom_ev_buffers);
908 delete [] _control_data;
909 delete [] _shadow_data;
911 delete [] _ev_buffers;
916 LV2Plugin::is_external_ui() const
921 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
925 LV2Plugin::is_external_kx() const
930 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
934 LV2Plugin::ui_is_resizable () const
936 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
937 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
938 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
939 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
941 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
942 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
944 lilv_nodes_free(nrs_matches);
945 lilv_nodes_free(fs_matches);
950 return !fs_matches && !nrs_matches;
955 LV2Plugin::has_inline_display () {
956 return _display_interface ? true : false;
959 Plugin::Display_Image_Surface*
960 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
961 if (_display_interface) {
962 /* Plugin::Display_Image_Surface is identical to
963 * LV2_Inline_Display_Image_Surface */
964 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
970 LV2Plugin::has_midnam () {
971 return _midname_interface ? true : false;
975 LV2Plugin::read_midnam () {
977 if (!_midname_interface) {
980 char* midnam = _midname_interface->midnam ((void*)_impl->instance->lv2_handle);
982 std::stringstream ss;
985 rv = MIDI::Name::MidiPatchManager::instance().update_custom_midnam (ss.str(), midnam);
989 info << string_compose(_("LV2: update midnam for plugin '%1'"), name ()) << endmsg;
991 warning << string_compose(_("LV2: Failed to parse midnam of plugin '%1'"), name ()) << endmsg;
994 _midname_interface->free (midnam);
999 LV2Plugin::midnam_model () {
1001 if (!_midname_interface) {
1004 char* model = _midname_interface->model ((void*)_impl->instance->lv2_handle);
1008 _midname_interface->free (model);
1014 LV2Plugin::unique_id() const
1016 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1020 LV2Plugin::uri() const
1022 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1026 LV2Plugin::label() const
1028 return lilv_node_as_string(_impl->name);
1032 LV2Plugin::name() const
1034 return lilv_node_as_string(_impl->name);
1038 LV2Plugin::maker() const
1040 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
1044 LV2Plugin::num_ports() const
1046 return lilv_plugin_get_num_ports(_impl->plugin);
1050 LV2Plugin::parameter_count() const
1052 return lilv_plugin_get_num_ports(_impl->plugin);
1056 LV2Plugin::default_value(uint32_t port)
1058 return _defaults[port];
1062 LV2Plugin::port_symbol(uint32_t index) const
1064 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
1066 error << name() << ": Invalid port index " << index << endmsg;
1069 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
1070 return lilv_node_as_string(sym);
1074 LV2Plugin::port_index (const char* symbol) const
1076 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
1077 if (i != _port_indices.end()) {
1080 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
1081 return (uint32_t)-1;
1086 LV2Plugin::set_parameter(uint32_t which, float val)
1088 DEBUG_TRACE(DEBUG::LV2, string_compose(
1089 "%1 set parameter %2 to %3\n", name(), which, val));
1091 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
1092 if (get_parameter (which) == val) {
1096 _shadow_data[which] = val;
1098 warning << string_compose(
1099 _("Illegal parameter number used with plugin \"%1\". "
1100 "This is a bug in either %2 or the LV2 plugin <%3>"),
1101 name(), PROGRAM_NAME, unique_id()) << endmsg;
1104 Plugin::set_parameter(which, val);
1108 LV2Plugin::get_parameter(uint32_t which) const
1110 if (parameter_is_input(which)) {
1111 return (float)_shadow_data[which];
1113 return (float)_control_data[which];
1119 LV2Plugin::get_docs() const
1121 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1123 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1124 lilv_nodes_free(comments);
1132 LV2Plugin::get_parameter_docs(uint32_t which) const
1134 LilvNodes* comments = lilv_port_get_value(
1136 lilv_plugin_get_port_by_index(_impl->plugin, which),
1137 _world.rdfs_comment);
1140 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1141 lilv_nodes_free(comments);
1149 LV2Plugin::get_layout (uint32_t which, UILayoutHint& h) const
1151 /// TODO lookup port-properties
1152 if (unique_id () != "urn:ardour:a-eq") {
1157 case 0: h.x0 = 0; h.x1 = 1; h.y0 = 2; h.y1 = 3; break; // Frequency L
1158 case 1: h.x0 = 0; h.x1 = 1; h.y0 = 0; h.y1 = 1; break; // Gain L
1159 case 17: h.x0 = 0; h.x1 = 1; h.y0 = 5; h.y1 = 6; break; // enable L
1161 case 2: h.x0 = 1; h.x1 = 3; h.y0 = 2; h.y1 = 3; break; // Frequency 1
1162 case 3: h.x0 = 1; h.x1 = 3; h.y0 = 0; h.y1 = 1; break; // Gain 1
1163 case 4: h.x0 = 2; h.x1 = 4; h.y0 = 1; h.y1 = 2; break; // Bandwidth 1
1164 case 18: h.x0 = 1; h.x1 = 4; h.y0 = 5; h.y1 = 6; break; // enable 1
1166 case 5: h.x0 = 4; h.x1 = 6; h.y0 = 2; h.y1 = 3; break; // Frequency 2
1167 case 6: h.x0 = 4; h.x1 = 6; h.y0 = 0; h.y1 = 1; break; // Gain 2
1168 case 7: h.x0 = 5; h.x1 = 7; h.y0 = 1; h.y1 = 2; break; // Bandwidth 2
1169 case 19: h.x0 = 4; h.x1 = 7; h.y0 = 5; h.y1 = 6; break; // enable 2
1171 case 8: h.x0 = 7; h.x1 = 9; h.y0 = 2; h.y1 = 3; break; // Frequency 3
1172 case 9: h.x0 = 7; h.x1 = 9; h.y0 = 0; h.y1 = 1; break; // Gain 3
1173 case 10: h.x0 = 8; h.x1 = 10; h.y0 = 1; h.y1 = 2; break; // Bandwidth 3
1174 case 20: h.x0 = 7; h.x1 = 10; h.y0 = 5; h.y1 = 6; break; // enable 3
1176 case 11: h.x0 = 10; h.x1 = 12; h.y0 = 2; h.y1 = 3; break; // Frequency 4
1177 case 12: h.x0 = 10; h.x1 = 12; h.y0 = 0; h.y1 = 1; break; // Gain 4
1178 case 13: h.x0 = 11; h.x1 = 13; h.y0 = 1; h.y1 = 2; break; // Bandwidth 4
1179 case 21: h.x0 = 10; h.x1 = 13; h.y0 = 5; h.y1 = 6; break; // enable 4
1181 case 14: h.x0 = 13; h.x1 = 14; h.y0 = 2; h.y1 = 3; break; // Frequency H
1182 case 15: h.x0 = 13; h.x1 = 14; h.y0 = 0; h.y1 = 1; break; // Gain H
1183 case 22: h.x0 = 13; h.x1 = 14; h.y0 = 5; h.y1 = 6; break; // enable H
1185 case 16: h.x0 = 14; h.x1 = 15; h.y0 = 1; h.y1 = 3; break; // Master Gain
1186 case 23: h.x0 = 14; h.x1 = 15; h.y0 = 5; h.y1 = 6; break; // Master Enable
1194 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1197 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1198 if (parameter_is_control(x)) {
1210 LV2Plugin::extension_data(const char* uri) const
1212 return lilv_instance_get_extension_data(_impl->instance, uri);
1216 LV2Plugin::c_plugin()
1218 return _impl->plugin;
1224 return (const void*)_impl->ui;
1228 LV2Plugin::c_ui_type()
1230 return (const void*)_impl->ui_type;
1233 /** Directory for all plugin state. */
1235 LV2Plugin::plugin_dir() const
1237 if (!_plugin_state_dir.empty ()){
1238 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1240 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1244 /** Directory for files created by the plugin (except during save). */
1246 LV2Plugin::scratch_dir() const
1248 return Glib::build_filename(plugin_dir(), "scratch");
1251 /** Directory for snapshots of files in the scratch directory. */
1253 LV2Plugin::file_dir() const
1255 return Glib::build_filename(plugin_dir(), "files");
1258 /** Directory to save state snapshot version @c num into. */
1260 LV2Plugin::state_dir(unsigned num) const
1262 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1265 /** Implementation of state:makePath for files created at instantiation time.
1266 * Note this is not used for files created at save time (Lilv deals with that).
1269 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1272 LV2Plugin* me = (LV2Plugin*)handle;
1273 if (me->_insert_id == PBD::ID("0")) {
1274 warning << string_compose(
1275 "File path \"%1\" requested but LV2 %2 has no insert ID",
1276 path, me->name()) << endmsg;
1277 return g_strdup(path);
1280 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1281 const std::string dirname = Glib::path_get_dirname(abs_path);
1282 g_mkdir_with_parents(dirname.c_str(), 0744);
1284 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1287 return g_strndup(abs_path.c_str(), abs_path.length());
1291 LV2Plugin::add_state(XMLNode* root) const
1293 assert(_insert_id != PBD::ID("0"));
1299 for (uint32_t i = 0; i < parameter_count(); ++i) {
1300 if (parameter_is_input(i) && parameter_is_control(i)) {
1301 child = new XMLNode("Port");
1302 child->add_property("symbol", port_symbol(i));
1303 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1304 child->add_property("value", string(buf));
1305 root->add_child_nocopy(*child);
1309 if (!_plugin_state_dir.empty()) {
1310 root->add_property("template-dir", _plugin_state_dir);
1313 if (_has_state_interface) {
1314 // Provisionally increment state version and create directory
1315 const std::string new_dir = state_dir(++_state_version);
1316 g_mkdir_with_parents(new_dir.c_str(), 0744);
1318 LilvState* state = lilv_state_new_from_instance(
1321 _uri_map.urid_map(),
1322 scratch_dir().c_str(),
1324 _session.externals_dir().c_str(),
1327 const_cast<LV2Plugin*>(this),
1331 if (!_plugin_state_dir.empty() || force_state_save
1333 || !lilv_state_equals(state, _impl->state)) {
1334 lilv_state_save(_world.world,
1335 _uri_map.urid_map(),
1336 _uri_map.urid_unmap(),
1342 if (force_state_save) {
1343 // archive or save-as
1344 lilv_state_free(state);
1347 else if (_plugin_state_dir.empty()) {
1348 // normal session save
1349 lilv_state_free(_impl->state);
1350 _impl->state = state;
1352 // template save (dedicated state-dir)
1353 lilv_state_free(state);
1357 // State is identical, decrement version and nuke directory
1358 lilv_state_free(state);
1359 PBD::remove_directory(new_dir);
1363 root->add_property("state-dir", string_compose("state%1", _state_version));
1367 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1369 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1371 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1373 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1374 lilv_nodes_free(vs);
1381 LV2Plugin::find_presets()
1383 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1384 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1385 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1387 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1388 LILV_FOREACH(nodes, i, presets) {
1389 const LilvNode* preset = lilv_nodes_get(presets, i);
1390 lilv_world_load_resource(_world.world, preset);
1391 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1392 bool userpreset = true; // TODO
1394 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1395 Plugin::PresetRecord(
1396 lilv_node_as_string(preset),
1397 lilv_node_as_string(name),
1399 lilv_node_free(name);
1401 warning << string_compose(
1402 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1403 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1404 lilv_node_as_string(preset)) << endmsg;
1407 lilv_nodes_free(presets);
1409 lilv_node_free(rdfs_label);
1410 lilv_node_free(pset_Preset);
1411 lilv_node_free(lv2_appliesTo);
1415 set_port_value(const char* port_symbol,
1421 LV2Plugin* self = (LV2Plugin*)user_data;
1422 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1423 return; // TODO: Support non-float ports
1426 const uint32_t port_index = self->port_index(port_symbol);
1427 if (port_index != (uint32_t)-1) {
1428 self->set_parameter(port_index, *(const float*)value);
1433 LV2Plugin::load_preset(PresetRecord r)
1435 LilvWorld* world = _world.world;
1436 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1437 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1439 const LV2_Feature* state_features[2] = { NULL, NULL };
1440 LV2_Worker_Schedule schedule = { _state_worker, work_schedule };
1441 const LV2_Feature state_sched_feature = { LV2_WORKER__schedule, &schedule };
1442 if (_state_worker) {
1443 state_features[0] = &state_sched_feature;
1447 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, state_features);
1448 lilv_state_free(state);
1449 Plugin::load_preset(r);
1452 lilv_node_free(pset);
1457 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1462 LV2Plugin *plugin = (LV2Plugin *) user_data;
1464 uint32_t index = plugin->port_index(port_symbol);
1465 if (index != (uint32_t) -1) {
1466 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1468 *size = sizeof(float);
1469 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1470 value = &plugin->_shadow_data[index];
1482 LV2Plugin::do_save_preset(string name)
1484 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1485 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1486 const string base_name = legalize_for_uri(name);
1487 const string file_name = base_name + ".ttl";
1488 const string bundle = Glib::build_filename(
1489 Glib::get_home_dir(),
1490 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1492 #ifdef HAVE_LILV_0_21_3
1493 /* delete reference to old preset (if any) */
1494 const PresetRecord* r = preset_by_label(name);
1496 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1498 lilv_world_unload_resource (_world.world, pset);
1499 lilv_node_free(pset);
1504 LilvState* state = lilv_state_new_from_instance(
1507 _uri_map.urid_map(),
1508 scratch_dir().c_str(), // file_dir
1509 bundle.c_str(), // copy_dir
1510 bundle.c_str(), // link_dir
1511 bundle.c_str(), // save_dir
1512 lv2plugin_get_port_value, // get_value
1513 (void*)this, // user_data
1514 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1515 _features // features
1518 lilv_state_set_label(state, name.c_str());
1520 _world.world, // world
1521 _uri_map.urid_map(), // map
1522 _uri_map.urid_unmap(), // unmap
1524 NULL, // uri (NULL = use file URI)
1525 bundle.c_str(), // dir
1526 file_name.c_str() // filename
1529 lilv_state_free(state);
1531 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1532 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1533 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1534 #ifdef HAVE_LILV_0_21_3
1535 lilv_world_unload_resource(_world.world, node_preset);
1536 lilv_world_unload_bundle(_world.world, node_bundle);
1538 lilv_world_load_bundle(_world.world, node_bundle);
1539 lilv_world_load_resource(_world.world, node_preset);
1540 lilv_node_free(node_bundle);
1541 lilv_node_free(node_preset);
1542 lilv_node_free(plug_name);
1547 LV2Plugin::do_remove_preset(string name)
1549 #ifdef HAVE_LILV_0_21_3
1550 /* Look up preset record by label (FIXME: ick, label as ID) */
1551 const PresetRecord* r = preset_by_label(name);
1556 /* Load a LilvState for the preset. */
1557 LilvWorld* world = _world.world;
1558 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1559 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1561 lilv_node_free(pset);
1565 /* Unload preset from world. */
1566 lilv_world_unload_resource(world, pset);
1568 /* Delete it from the file system. This will remove the preset file and the entry
1569 from the manifest. If this results in an empty manifest (i.e. the
1570 preset is the only thing in the bundle), then the bundle is removed. */
1571 lilv_state_delete(world, state);
1573 lilv_state_free(state);
1574 lilv_node_free(pset);
1576 /* Without lilv_state_delete(), we could delete the preset file, but this
1577 would leave a broken bundle/manifest around, so the preset would still
1578 be visible, but broken. Naively deleting a bundle is too dangerous, so
1579 we simply do not support preset deletion with older Lilv */
1583 LV2Plugin::has_editor() const
1585 return _impl->ui != NULL;
1589 LV2Plugin::has_message_output() const
1591 for (uint32_t i = 0; i < num_ports(); ++i) {
1592 if ((_port_flags[i] & PORT_SEQUENCE) &&
1593 (_port_flags[i] & PORT_OUTPUT)) {
1601 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1605 const uint8_t* body)
1607 const uint32_t buf_size = sizeof(UIMessage) + size;
1608 vector<uint8_t> buf(buf_size);
1610 UIMessage* msg = (UIMessage*)&buf[0];
1612 msg->protocol = protocol;
1614 memcpy(msg + 1, body, size);
1616 return (dest->write(&buf[0], buf_size) == buf_size);
1620 LV2Plugin::write_from_ui(uint32_t index,
1623 const uint8_t* body)
1626 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1627 /* buffer data communication from plugin UI to plugin instance.
1628 * this buffer needs to potentially hold
1629 * (port's minimumSize) * (audio-periods) / (UI-periods)
1632 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1633 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1634 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1636 * it is NOT safe to overflow (msg.size will be misinterpreted)
1638 uint32_t bufsiz = 32768;
1639 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1640 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1642 rbs = max((size_t) bufsiz * 8, rbs);
1643 _from_ui = new RingBuffer<uint8_t>(rbs);
1646 if (!write_to(_from_ui, index, protocol, size, body)) {
1647 error << "Error writing from UI to plugin" << endmsg;
1654 LV2Plugin::write_to_ui(uint32_t index,
1657 const uint8_t* body)
1659 if (!write_to(_to_ui, index, protocol, size, body)) {
1660 error << "Error writing from plugin to UI" << endmsg;
1667 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1669 switch (value.type()) {
1670 case Variant::NOTHING:
1672 case Variant::BEATS:
1673 // No atom type for this, just forge a double
1674 lv2_atom_forge_double(forge, value.get_beats().to_double());
1677 lv2_atom_forge_bool(forge, value.get_bool());
1679 case Variant::DOUBLE:
1680 lv2_atom_forge_double(forge, value.get_double());
1682 case Variant::FLOAT:
1683 lv2_atom_forge_float(forge, value.get_float());
1686 lv2_atom_forge_int(forge, value.get_int());
1689 lv2_atom_forge_long(forge, value.get_long());
1692 lv2_atom_forge_path(
1693 forge, value.get_path().c_str(), value.get_path().size());
1695 case Variant::STRING:
1696 lv2_atom_forge_string(
1697 forge, value.get_string().c_str(), value.get_string().size());
1701 forge, value.get_uri().c_str(), value.get_uri().size());
1706 /** Get a variant type from a URI, return false iff no match found. */
1708 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1710 if (uri == LV2_ATOM__Bool) {
1711 type = Variant::BOOL;
1712 } else if (uri == LV2_ATOM__Double) {
1713 type = Variant::DOUBLE;
1714 } else if (uri == LV2_ATOM__Float) {
1715 type = Variant::FLOAT;
1716 } else if (uri == LV2_ATOM__Int) {
1717 type = Variant::INT;
1718 } else if (uri == LV2_ATOM__Long) {
1719 type = Variant::LONG;
1720 } else if (uri == LV2_ATOM__Path) {
1721 type = Variant::PATH;
1722 } else if (uri == LV2_ATOM__String) {
1723 type = Variant::STRING;
1724 } else if (uri == LV2_ATOM__URI) {
1725 type = Variant::URI;
1733 LV2Plugin::set_property(uint32_t key, const Variant& value)
1735 if (_patch_port_in_index == (uint32_t)-1) {
1736 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1738 } else if (value.type() == Variant::NOTHING) {
1739 error << "LV2: set_property called with void value" << endmsg;
1743 // Set up forge to write to temporary buffer on the stack
1744 LV2_Atom_Forge* forge = &_impl->ui_forge;
1745 LV2_Atom_Forge_Frame frame;
1746 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1748 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1750 // Serialize patch:Set message to set property
1751 #ifdef HAVE_LV2_1_10_0
1752 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1753 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1754 lv2_atom_forge_urid(forge, key);
1755 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1757 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1758 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1759 lv2_atom_forge_urid(forge, key);
1760 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1763 forge_variant(forge, value);
1765 // Write message to UI=>Plugin ring
1766 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1767 write_from_ui(_patch_port_in_index,
1768 _uri_map.urids.atom_eventTransfer,
1769 lv2_atom_total_size(atom),
1770 (const uint8_t*)atom);
1773 const ParameterDescriptor&
1774 LV2Plugin::get_property_descriptor(uint32_t id) const
1776 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1777 if (p != _property_descriptors.end()) {
1780 return Plugin::get_property_descriptor(id);
1784 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1786 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1787 desc.unit = ParameterDescriptor::MIDI_NOTE;
1788 } else if (lilv_nodes_contains(units, _world.units_db)) {
1789 desc.unit = ParameterDescriptor::DB;
1790 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1791 desc.unit = ParameterDescriptor::HZ;
1793 if (lilv_nodes_size(units) > 0) {
1794 const LilvNode* unit = lilv_nodes_get_first(units);
1795 LilvNode* render = get_value(lworld, unit, _world.units_render);
1797 desc.print_fmt = lilv_node_as_string(render);
1798 replace_all (desc.print_fmt, "%f", "%.2f");
1799 lilv_node_free(render);
1805 load_parameter_descriptor(LV2World& world,
1806 ParameterDescriptor& desc,
1807 Variant::Type datatype,
1808 const LilvNode* subject)
1810 LilvWorld* lworld = _world.world;
1811 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1812 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1813 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1814 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1815 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1817 desc.label = lilv_node_as_string(label);
1819 if (def && lilv_node_is_float(def)) {
1820 desc.normal = lilv_node_as_float(def);
1822 if (minimum && lilv_node_is_float(minimum)) {
1823 desc.lower = lilv_node_as_float(minimum);
1825 if (maximum && lilv_node_is_float(maximum)) {
1826 desc.upper = lilv_node_as_float(maximum);
1828 load_parameter_descriptor_units(lworld, desc, units);
1829 desc.datatype = datatype;
1830 desc.toggled |= datatype == Variant::BOOL;
1831 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1832 desc.update_steps();
1834 lilv_nodes_free(units);
1835 lilv_node_free(label);
1836 lilv_node_free(def);
1837 lilv_node_free(minimum);
1838 lilv_node_free(maximum);
1842 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1844 LilvWorld* lworld = _world.world;
1845 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1846 LilvNodes* properties = lilv_world_find_nodes(
1847 lworld, subject, _world.patch_writable, NULL);
1848 LILV_FOREACH(nodes, p, properties) {
1849 // Get label and range
1850 const LilvNode* prop = lilv_nodes_get(properties, p);
1851 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1853 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1854 lilv_node_as_uri(prop)) << endmsg;
1858 // Convert range to variant type (TODO: support for multiple range types)
1859 Variant::Type datatype;
1860 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1861 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1862 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1866 // Add description to result
1867 ParameterDescriptor desc;
1868 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1869 desc.datatype = datatype;
1870 load_parameter_descriptor(_world, desc, datatype, prop);
1871 descs.insert(std::make_pair(desc.key, desc));
1873 lilv_node_free(range);
1875 lilv_nodes_free(properties);
1879 LV2Plugin::announce_property_values()
1881 if (_patch_port_in_index == (uint32_t)-1) {
1885 // Set up forge to write to temporary buffer on the stack
1886 LV2_Atom_Forge* forge = &_impl->ui_forge;
1887 LV2_Atom_Forge_Frame frame;
1888 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1890 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1892 // Serialize patch:Get message with no subject (implicitly plugin instance)
1893 #ifdef HAVE_LV2_1_10_0
1894 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1896 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1899 // Write message to UI=>Plugin ring
1900 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1901 write_from_ui(_patch_port_in_index,
1902 _uri_map.urids.atom_eventTransfer,
1903 lv2_atom_total_size(atom),
1904 (const uint8_t*)atom);
1908 LV2Plugin::enable_ui_emission()
1911 /* see note in LV2Plugin::write_from_ui() */
1912 uint32_t bufsiz = 32768;
1913 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1914 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1916 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1917 rbs = max((size_t) bufsiz * 8, rbs);
1918 _to_ui = new RingBuffer<uint8_t>(rbs);
1923 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1929 uint32_t read_space = _to_ui->read_space();
1930 while (read_space > sizeof(UIMessage)) {
1932 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1933 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1936 vector<uint8_t> body(msg.size);
1937 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1938 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1942 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1944 read_space -= sizeof(msg) + msg.size;
1949 LV2Plugin::work(Worker& worker, uint32_t size, const void* data)
1951 Glib::Threads::Mutex::Lock lm(_work_mutex);
1952 return _impl->work_iface->work(
1953 _impl->instance->lv2_handle, work_respond, &worker, size, data);
1957 LV2Plugin::work_response(uint32_t size, const void* data)
1959 return _impl->work_iface->work_response(
1960 _impl->instance->lv2_handle, size, data);
1964 LV2Plugin::set_insert_id(PBD::ID id)
1966 if (_insert_id == "0") {
1968 } else if (_insert_id != id) {
1969 lilv_state_free(_impl->state);
1970 _impl->state = NULL;
1976 LV2Plugin::set_state_dir (const std::string& d)
1978 _plugin_state_dir = d;
1982 LV2Plugin::set_state(const XMLNode& node, int version)
1985 XMLProperty const * prop;
1986 XMLNodeConstIterator iter;
1993 if (node.name() != state_node_name()) {
1994 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1998 #ifndef NO_PLUGIN_STATE
2000 if (version < 3000) {
2001 nodes = node.children("port");
2003 nodes = node.children("Port");
2006 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
2010 if ((prop = child->property("symbol")) != 0) {
2011 sym = prop->value().c_str();
2013 warning << _("LV2: port has no symbol, ignored") << endmsg;
2017 map<string, uint32_t>::iterator i = _port_indices.find(sym);
2019 if (i != _port_indices.end()) {
2020 port_id = i->second;
2022 warning << _("LV2: port has unknown index, ignored") << endmsg;
2026 if ((prop = child->property("value")) != 0) {
2027 value = prop->value().c_str();
2029 warning << _("LV2: port has no value, ignored") << endmsg;
2033 set_parameter(port_id, atof(value));
2036 if ((prop = node.property("template-dir")) != 0) {
2037 set_state_dir (prop->value ());
2041 if ((prop = node.property("state-dir")) != 0) {
2042 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
2043 error << string_compose(
2044 "LV2: failed to parse state version from \"%1\"",
2045 prop->value()) << endmsg;
2048 std::string state_file = Glib::build_filename(
2050 Glib::build_filename(prop->value(), "state.ttl"));
2052 LilvState* state = lilv_state_new_from_file(
2053 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
2055 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
2056 lilv_state_free(_impl->state);
2057 _impl->state = state;
2060 if (!_plugin_state_dir.empty ()) {
2061 // force save with session, next time (increment counter)
2062 lilv_state_free (_impl->state);
2063 _impl->state = NULL;
2067 latency_compute_run();
2070 return Plugin::set_state(node, version);
2074 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
2076 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
2078 error << string_compose("LV2: get descriptor of non-existent port %1", which)
2083 LilvNodes* portunits;
2084 LilvNode *def, *min, *max;
2085 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
2086 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
2088 LilvNode* steps = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
2090 // TODO: Once we can rely on lilv 0.18.0 being present,
2091 // load_parameter_descriptor() can be used for ports as well
2092 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
2093 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
2094 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
2095 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
2096 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
2097 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
2098 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
2099 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
2100 load_parameter_descriptor_units(_world.world, desc, portunits);
2102 if (desc.sr_dependent) {
2103 desc.lower *= _session.frame_rate ();
2104 desc.upper *= _session.frame_rate ();
2107 desc.min_unbound = false; // TODO: LV2 extension required
2108 desc.max_unbound = false; // TODO: LV2 extension required
2110 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
2111 desc.scale_points = get_scale_points(which);
2113 desc.update_steps();
2116 //override auto-calculated steps in update_steps()
2117 float s = lilv_node_as_float (steps);
2118 const float delta = desc.upper - desc.lower;
2120 desc.step = desc.smallstep = (delta / s);
2121 desc.largestep = std::min ((delta / 5.0f), 10.f * desc.smallstep);
2123 if (desc.logarithmic) {
2124 // TODO marry AutomationControl::internal_to_interface () with
2125 // http://lv2plug.in/ns/ext/port-props/#rangeSteps
2126 desc.smallstep = desc.smallstep / logf(s);
2127 desc.step = desc.step / logf(s);
2128 desc.largestep = desc.largestep / logf(s);
2129 } else if (desc.integer_step) {
2130 desc.smallstep = 1.0;
2131 desc.step = std::max(1.f, rintf (desc.step));
2132 desc.largestep = std::max(1.f, rintf (desc.largestep));
2134 DEBUG_TRACE(DEBUG::LV2, string_compose("parameter %1 small: %2, step: %3 largestep: %4\n",
2135 which, desc.smallstep, desc.step, desc.largestep));
2139 lilv_node_free(def);
2140 lilv_node_free(min);
2141 lilv_node_free(max);
2142 lilv_node_free(steps);
2143 lilv_nodes_free(portunits);
2148 Plugin::IOPortDescription
2149 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2151 PortFlags match = 0;
2153 case DataType::AUDIO:
2156 case DataType::MIDI:
2157 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2160 return Plugin::IOPortDescription ("?");
2164 match |= PORT_INPUT;
2166 match |= PORT_OUTPUT;
2170 uint32_t idx = UINT32_MAX;
2172 uint32_t const num_ports = parameter_count();
2173 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2174 PortFlags flags = _port_flags[port_index];
2175 if ((flags & match) == match) {
2182 if (idx == UINT32_MAX) {
2183 return Plugin::IOPortDescription ("?");
2186 LilvNode* name = lilv_port_get_name(_impl->plugin,
2187 lilv_plugin_get_port_by_index(_impl->plugin, idx));
2188 Plugin::IOPortDescription iod (lilv_node_as_string (name));
2189 lilv_node_free(name);
2191 if (lilv_port_has_property(_impl->plugin,
2192 lilv_plugin_get_port_by_index(_impl->plugin, idx), _world.lv2_isSideChain)) {
2193 iod.is_sidechain = true;
2199 LV2Plugin::describe_parameter(Evoral::Parameter which)
2201 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2203 if (lilv_port_has_property(_impl->plugin,
2204 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2205 return X_("hidden");
2208 if (lilv_port_has_property(_impl->plugin,
2209 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2210 return X_("hidden");
2213 if (lilv_port_has_property(_impl->plugin,
2214 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2215 return X_("latency");
2218 LilvNode* name = lilv_port_get_name(_impl->plugin,
2219 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2220 string ret(lilv_node_as_string(name));
2221 lilv_node_free(name);
2229 LV2Plugin::max_latency () const
2231 return _max_latency;
2235 LV2Plugin::signal_latency() const
2237 if (_latency_control_port) {
2238 return (framecnt_t)floor(*_latency_control_port);
2244 set<Evoral::Parameter>
2245 LV2Plugin::automatable() const
2247 set<Evoral::Parameter> ret;
2249 for (uint32_t i = 0; i < parameter_count(); ++i) {
2250 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2251 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2255 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2256 p != _property_descriptors.end();
2258 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2264 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2266 if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2267 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2268 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2272 LV2Plugin::AutomationCtrlPtr
2273 LV2Plugin::get_automation_control (uint32_t i)
2275 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2276 return AutomationCtrlPtr ();
2278 return _ctrl_map[i];
2282 LV2Plugin::activate()
2284 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2286 if (!_was_activated) {
2287 lilv_instance_activate(_impl->instance);
2288 _was_activated = true;
2293 LV2Plugin::deactivate()
2295 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2297 if (_was_activated) {
2298 lilv_instance_deactivate(_impl->instance);
2299 _was_activated = false;
2304 LV2Plugin::cleanup()
2306 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2309 lilv_instance_free(_impl->instance);
2310 _impl->instance = NULL;
2314 LV2Plugin::allocate_atom_event_buffers()
2316 /* reserve local scratch buffers for ATOM event-queues */
2317 const LilvPlugin* p = _impl->plugin;
2319 /* count non-MIDI atom event-ports
2320 * TODO: nicely ask drobilla to make a lilv_ call for that
2322 int count_atom_out = 0;
2323 int count_atom_in = 0;
2324 int minimumSize = 32768; // TODO use a per-port minimum-size
2325 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2326 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2327 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2328 LilvNodes* buffer_types = lilv_port_get_value(
2329 p, port, _world.atom_bufferType);
2330 LilvNodes* atom_supports = lilv_port_get_value(
2331 p, port, _world.atom_supports);
2333 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2334 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2337 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2340 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2341 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2342 if (min_size && lilv_node_is_int(min_size)) {
2343 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2345 lilv_nodes_free(min_size_v);
2347 lilv_nodes_free(buffer_types);
2348 lilv_nodes_free(atom_supports);
2352 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2353 name(), count_atom_in, count_atom_out));
2355 const int total_atom_buffers = (count_atom_in + count_atom_out);
2356 if (_atom_ev_buffers || total_atom_buffers == 0) {
2360 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2361 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2362 for (int i = 0; i < total_atom_buffers; ++i ) {
2363 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2364 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2366 _atom_ev_buffers[total_atom_buffers] = 0;
2370 /** Write an ardour position/time/tempo/meter as an LV2 event.
2371 * @return true on success.
2374 write_position(LV2_Atom_Forge* forge,
2376 const TempoMetric& t,
2377 Timecode::BBT_Time& bbt,
2380 framepos_t position,
2383 const URIMap::URIDs& urids = URIMap::instance().urids;
2385 uint8_t pos_buf[256];
2386 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2387 LV2_Atom_Forge_Frame frame;
2388 #ifdef HAVE_LV2_1_10_0
2389 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2390 lv2_atom_forge_key(forge, urids.time_frame);
2391 lv2_atom_forge_long(forge, position);
2392 lv2_atom_forge_key(forge, urids.time_speed);
2393 lv2_atom_forge_float(forge, speed);
2394 lv2_atom_forge_key(forge, urids.time_barBeat);
2395 lv2_atom_forge_float(forge, bbt.beats - 1 +
2396 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2397 lv2_atom_forge_key(forge, urids.time_bar);
2398 lv2_atom_forge_long(forge, bbt.bars - 1);
2399 lv2_atom_forge_key(forge, urids.time_beatUnit);
2400 lv2_atom_forge_int(forge, t.meter().note_divisor());
2401 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2402 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2403 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2404 lv2_atom_forge_float(forge, bpm);
2406 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2407 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2408 lv2_atom_forge_long(forge, position);
2409 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2410 lv2_atom_forge_float(forge, speed);
2411 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2412 lv2_atom_forge_float(forge, bbt.beats - 1 +
2413 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2414 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2415 lv2_atom_forge_long(forge, bbt.bars - 1);
2416 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2417 lv2_atom_forge_int(forge, t.meter().note_divisor());
2418 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2419 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2420 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2421 lv2_atom_forge_float(forge, bpm);
2424 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2425 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2426 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2427 (const uint8_t*)(atom + 1));
2431 LV2Plugin::connect_and_run(BufferSet& bufs,
2432 framepos_t start, framepos_t end, double speed,
2433 ChanMapping in_map, ChanMapping out_map,
2434 pframes_t nframes, framecnt_t offset)
2436 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2437 Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2439 cycles_t then = get_cycles();
2441 TempoMap& tmap = _session.tempo_map();
2442 Metrics::const_iterator metric_i = tmap.metrics_end();
2443 TempoMetric tmetric = tmap.metric_at(start, &metric_i);
2445 if (_freewheel_control_port) {
2446 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2449 if (_bpm_control_port) {
2450 *_bpm_control_port = tmap.tempo_at_frame (start).beats_per_minute();
2454 if (_can_write_automation && start != _next_cycle_start) {
2455 // add guard-points after locating
2456 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2457 i->second->guard = true;
2462 ChanCount bufs_count;
2463 bufs_count.set(DataType::AUDIO, 1);
2464 bufs_count.set(DataType::MIDI, 1);
2465 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2466 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2467 uint32_t const num_ports = parameter_count();
2468 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2470 uint32_t audio_in_index = 0;
2471 uint32_t audio_out_index = 0;
2472 uint32_t midi_in_index = 0;
2473 uint32_t midi_out_index = 0;
2474 uint32_t atom_port_index = 0;
2475 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2477 uint32_t index = nil_index;
2478 PortFlags flags = _port_flags[port_index];
2480 if (flags & PORT_AUDIO) {
2481 if (flags & PORT_INPUT) {
2482 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2484 ? bufs.get_audio(index).data(offset)
2485 : silent_bufs.get_audio(0).data(offset);
2487 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2489 ? bufs.get_audio(index).data(offset)
2490 : scratch_bufs.get_audio(0).data(offset);
2492 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2493 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2494 be necessary, but the mapping is illegal in some cases. Ideally
2495 that should be fixed, but this is easier...
2497 if (flags & PORT_MIDI) {
2498 if (flags & PORT_INPUT) {
2499 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2501 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2503 if (valid && bufs.count().n_midi() > index) {
2504 /* Note, ensure_lv2_bufsize() is not RT safe!
2505 * However free()/alloc() is only called if a
2506 * plugin requires a rsz:minimumSize buffersize
2507 * and the existing buffer if smaller.
2509 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2510 _ev_buffers[port_index] = bufs.get_lv2_midi(
2511 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2513 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2514 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2515 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2519 if (valid && (flags & PORT_INPUT)) {
2520 if ((flags & PORT_POSITION)) {
2521 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2522 double bpm = tmap.tempo_at_frame (start).beats_per_minute();
2523 double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
2525 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2526 beatpos *= tmetric.meter().note_divisor() / 4.0;
2527 if (start != _next_cycle_start ||
2528 speed != _next_cycle_speed ||
2529 rint (1000 * beatpos) != rint(1000 * _next_cycle_beat) ||
2530 bpm != _current_bpm) {
2531 // Transport or Tempo has changed, write position at cycle start
2532 write_position(&_impl->forge, _ev_buffers[port_index],
2533 tmetric, bbt, speed, bpm, start, 0);
2537 // Get MIDI iterator range (empty range if no MIDI)
2538 MidiBuffer::iterator m = (index != nil_index)
2539 ? bufs.get_midi(index).begin()
2540 : silent_bufs.get_midi(0).end();
2541 MidiBuffer::iterator m_end = (index != nil_index)
2542 ? bufs.get_midi(index).end()
2545 // Now merge MIDI and any transport events into the buffer
2546 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2547 const framepos_t tend = end;
2549 while (m != m_end || (metric_i != tmap.metrics_end() &&
2550 (*metric_i)->frame() < tend)) {
2551 MetricSection* metric = (metric_i != tmap.metrics_end())
2553 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2554 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2555 if (ev.time() < nframes) {
2556 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2557 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2561 tmetric.set_metric(metric);
2562 Timecode::BBT_Time bbt;
2563 bbt = tmap.bbt_at_pulse (metric->pulse());
2564 double bpm = tmap.tempo_at_frame (start/*XXX*/).beats_per_minute();
2565 write_position(&_impl->forge, _ev_buffers[port_index],
2566 tmetric, bbt, speed, bpm,
2568 metric->frame() - start);
2572 } else if (!valid) {
2573 // Nothing we understand or care about, connect to scratch
2574 // see note for midi-buffer size above
2575 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2576 0, _port_minimumSize[port_index]);
2577 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2578 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2581 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2583 continue; // Control port, leave buffer alone
2585 lilv_instance_connect_port(_impl->instance, port_index, buf);
2588 // Read messages from UI and push into appropriate buffers
2590 uint32_t read_space = _from_ui->read_space();
2591 while (read_space > sizeof(UIMessage)) {
2593 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2594 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2597 vector<uint8_t> body(msg.size);
2598 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2599 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2602 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2603 LV2_Evbuf* buf = _ev_buffers[msg.index];
2604 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2605 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2606 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2607 (const uint8_t*)(atom + 1))) {
2608 error << "Failed to write data to LV2 event buffer\n";
2611 error << "Received unknown message type from UI" << endmsg;
2613 read_space -= sizeof(UIMessage) + msg.size;
2620 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2621 PortFlags flags = _port_flags[port_index];
2624 /* TODO ask drobilla about comment
2625 * "Make Ardour event buffers generic so plugins can communicate"
2626 * in libs/ardour/buffer_set.cc:310
2628 * ideally the user could choose which of the following two modes
2629 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2631 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2632 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2633 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2634 * for quite a while at least ;)
2636 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2637 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2638 const uint32_t buf_index = out_map.get(
2639 DataType::MIDI, midi_out_index++, &valid);
2641 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2644 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2645 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2646 const uint32_t buf_index = out_map.get(
2647 DataType::MIDI, midi_out_index++, &valid);
2649 bufs.flush_lv2_midi(true, buf_index);
2653 // Write messages to UI
2654 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2655 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2656 LV2_Evbuf* buf = _ev_buffers[port_index];
2657 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2658 lv2_evbuf_is_valid(i);
2659 i = lv2_evbuf_next(i)) {
2660 uint32_t frames, subframes, type, size;
2662 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2665 // Intercept Automation Write Events
2666 if ((flags & PORT_AUTOCTRL)) {
2667 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2668 if (atom->type == _uri_map.urids.atom_Blank ||
2669 atom->type == _uri_map.urids.atom_Object) {
2670 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2671 if (obj->body.otype == _uri_map.urids.auto_event) {
2672 // only if transport_rolling ??
2673 const LV2_Atom* parameter = NULL;
2674 const LV2_Atom* value = NULL;
2675 lv2_atom_object_get(obj,
2676 _uri_map.urids.auto_parameter, ¶meter,
2677 _uri_map.urids.auto_value, &value,
2679 if (parameter && value) {
2680 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2681 const float v = ((const LV2_Atom_Float*)value)->body;
2682 // -> add automation event..
2683 DEBUG_TRACE(DEBUG::LV2Automate,
2684 string_compose ("Event p: %1 t: %2 v: %3\n", p, frames, v));
2685 AutomationCtrlPtr c = get_automation_control (p);
2687 (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2689 framepos_t when = std::max ((framepos_t) 0, start + frames - _current_latency);
2690 assert (start + frames - _current_latency >= 0);
2693 c->ac->list()->add (when, v, true, true);
2695 c->ac->set_double (v, when, true);
2700 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2701 // TODO optional arguments, for now we assume the plugin
2702 // writes automation for its own inputs
2703 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2704 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2705 if (_port_flags[i->first] & PORT_CTRLED) {
2706 DEBUG_TRACE(DEBUG::LV2Automate,
2707 string_compose ("Setup p: %1\n", i->first));
2708 i->second->ac->set_automation_state (Touch);
2712 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2713 // set [touched] parameters to "play" ??
2714 // allow plugin to change its mode (from analyze to apply)
2715 const LV2_Atom* parameter = NULL;
2716 const LV2_Atom* value = NULL;
2717 lv2_atom_object_get(obj,
2718 _uri_map.urids.auto_parameter, ¶meter,
2719 _uri_map.urids.auto_value, &value,
2721 if (parameter && value) {
2722 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2723 const float v = ((const LV2_Atom_Float*)value)->body;
2724 AutomationCtrlPtr c = get_automation_control (p);
2725 DEBUG_TRACE(DEBUG::LV2Automate,
2726 string_compose ("Finalize p: %1 v: %2\n", p, v));
2727 if (c && _port_flags[p] & PORT_CTRLER) {
2728 c->ac->set_value(v, Controllable::NoGroup);
2731 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2733 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2734 // guard will be false if an event was written
2735 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2736 DEBUG_TRACE(DEBUG::LV2Automate,
2737 string_compose ("Thin p: %1\n", i->first));
2738 i->second->ac->alist ()->thin (20);
2742 else if (obj->body.otype == _uri_map.urids.auto_start) {
2743 const LV2_Atom* parameter = NULL;
2744 lv2_atom_object_get(obj,
2745 _uri_map.urids.auto_parameter, ¶meter,
2748 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2749 AutomationCtrlPtr c = get_automation_control (p);
2750 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2752 c->ac->start_touch (std::max ((framepos_t)0, start - _current_latency));
2757 else if (obj->body.otype == _uri_map.urids.auto_end) {
2758 const LV2_Atom* parameter = NULL;
2759 lv2_atom_object_get(obj,
2760 _uri_map.urids.auto_parameter, ¶meter,
2763 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2764 AutomationCtrlPtr c = get_automation_control (p);
2765 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2767 c->ac->stop_touch (true, std::max ((framepos_t)0, start - _current_latency));
2774 // Intercept state dirty message
2775 if (_has_state_interface /* && (flags & PORT_DIRTYMSG)*/) {
2776 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2777 if (atom->type == _uri_map.urids.atom_Blank ||
2778 atom->type == _uri_map.urids.atom_Object) {
2779 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2780 if (obj->body.otype == _uri_map.urids.state_StateChanged) {
2781 _session.set_dirty ();
2786 // Intercept patch change messages to emit PropertyChanged signal
2787 if ((flags & PORT_PATCHMSG)) {
2788 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2789 if (atom->type == _uri_map.urids.atom_Blank ||
2790 atom->type == _uri_map.urids.atom_Object) {
2791 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2792 if (obj->body.otype == _uri_map.urids.patch_Set) {
2793 const LV2_Atom* property = NULL;
2794 const LV2_Atom* value = NULL;
2795 lv2_atom_object_get(obj,
2796 _uri_map.urids.patch_property, &property,
2797 _uri_map.urids.patch_value, &value,
2800 if (property && value &&
2801 property->type == _uri_map.urids.atom_URID &&
2802 value->type == _uri_map.urids.atom_Path) {
2803 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2804 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2806 // Emit PropertyChanged signal for UI
2807 // TODO: This should emit the control's Changed signal
2808 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2810 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2816 if (!_to_ui) continue;
2817 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2818 size + sizeof(LV2_Atom),
2819 data - sizeof(LV2_Atom));
2824 cycles_t now = get_cycles();
2825 set_cycles((uint32_t)(now - then));
2827 // Update expected transport information for next cycle so we can detect changes
2828 _next_cycle_speed = speed;
2829 _next_cycle_start = end;
2832 /* keep track of lv2:timePosition like plugins can do.
2833 * Note: for no-midi plugins, we only ever send information at cycle-start,
2834 * so it needs to be realative to that.
2836 TempoMetric t = tmap.metric_at(start);
2837 _current_bpm = tmap.tempo_at_frame (start).beats_per_minute();
2838 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2839 double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
2841 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2842 beatpos *= tmetric.meter().note_divisor() / 4.0;
2843 _next_cycle_beat = beatpos + nframes * speed * _current_bpm / (60.f * _session.frame_rate());
2846 if (_latency_control_port) {
2847 framecnt_t new_latency = signal_latency ();
2848 _current_latency = new_latency;
2854 LV2Plugin::parameter_is_control(uint32_t param) const
2856 assert(param < _port_flags.size());
2857 return _port_flags[param] & PORT_CONTROL;
2861 LV2Plugin::parameter_is_audio(uint32_t param) const
2863 assert(param < _port_flags.size());
2864 return _port_flags[param] & PORT_AUDIO;
2868 LV2Plugin::parameter_is_event(uint32_t param) const
2870 assert(param < _port_flags.size());
2871 return _port_flags[param] & PORT_EVENT;
2875 LV2Plugin::parameter_is_output(uint32_t param) const
2877 assert(param < _port_flags.size());
2878 return _port_flags[param] & PORT_OUTPUT;
2882 LV2Plugin::parameter_is_input(uint32_t param) const
2884 assert(param < _port_flags.size());
2885 return _port_flags[param] & PORT_INPUT;
2889 LV2Plugin::designated_bypass_port ()
2891 const LilvPort* port = NULL;
2892 LilvNode* designation = lilv_new_uri (_world.world, LV2_CORE_PREFIX "enabled");
2893 port = lilv_plugin_get_port_by_designation (
2894 _impl->plugin, _world.lv2_InputPort, designation);
2895 lilv_node_free(designation);
2897 return lilv_port_get_index (_impl->plugin, port);
2900 /* deprecated on 2016-Sep-18 in favor of lv2:enabled */
2901 designation = lilv_new_uri (_world.world, LV2_PROCESSING_URI__enable);
2902 port = lilv_plugin_get_port_by_designation (
2903 _impl->plugin, _world.lv2_InputPort, designation);
2904 lilv_node_free(designation);
2906 return lilv_port_get_index (_impl->plugin, port);
2913 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2916 if (param < parameter_count()) {
2917 snprintf(buf, len, "%.3f", get_parameter(param));
2924 boost::shared_ptr<ScalePoints>
2925 LV2Plugin::get_scale_points(uint32_t port_index) const
2927 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2928 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2930 boost::shared_ptr<ScalePoints> ret;
2935 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2937 LILV_FOREACH(scale_points, i, points) {
2938 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2939 const LilvNode* label = lilv_scale_point_get_label(p);
2940 const LilvNode* value = lilv_scale_point_get_value(p);
2941 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2942 ret->insert(make_pair(lilv_node_as_string(label),
2943 lilv_node_as_float(value)));
2947 lilv_scale_points_free(points);
2952 LV2Plugin::run(pframes_t nframes, bool sync_work)
2954 uint32_t const N = parameter_count();
2955 for (uint32_t i = 0; i < N; ++i) {
2956 if (parameter_is_control(i) && parameter_is_input(i)) {
2957 _control_data[i] = _shadow_data[i];
2962 // Execute work synchronously if we're freewheeling (export)
2963 _worker->set_synchronous(sync_work || session().engine().freewheeling());
2966 // Run the plugin for this cycle
2967 lilv_instance_run(_impl->instance, nframes);
2969 // Emit any queued worker responses (calls a plugin callback)
2970 if (_state_worker) {
2971 _state_worker->emit_responses();
2974 _worker->emit_responses();
2977 // Notify the plugin that a work run cycle is complete
2978 if (_impl->work_iface) {
2979 if (_impl->work_iface->end_run) {
2980 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2986 LV2Plugin::latency_compute_run()
2988 if (!_latency_control_port) {
2992 // Run the plugin so that it can set its latency parameter
2994 bool was_activated = _was_activated;
2997 uint32_t port_index = 0;
2998 uint32_t in_index = 0;
2999 uint32_t out_index = 0;
3001 // this is done in the main thread. non realtime.
3002 const framecnt_t bufsize = _engine.samples_per_cycle();
3003 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
3005 memset(buffer, 0, sizeof(float) * bufsize);
3007 // FIXME: Ensure plugins can handle in-place processing
3011 while (port_index < parameter_count()) {
3012 if (parameter_is_audio(port_index)) {
3013 if (parameter_is_input(port_index)) {
3014 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3016 } else if (parameter_is_output(port_index)) {
3017 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3026 if (was_activated) {
3033 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
3035 const LilvPort* port = NULL;
3036 LilvNode* designation = lilv_new_uri(_world.world, uri);
3037 port = lilv_plugin_get_port_by_designation(
3038 plugin, _world.lv2_InputPort, designation);
3039 lilv_node_free(designation);
3041 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
3046 static bool lv2_filter (const string& str, void* /*arg*/)
3048 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
3050 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
3054 LV2World::LV2World()
3055 : world(lilv_world_new())
3056 , _bundle_checked(false)
3058 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
3059 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
3060 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
3061 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
3062 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
3063 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
3064 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
3065 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
3066 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
3067 ext_expensive = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
3068 ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
3069 ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
3070 ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
3071 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
3072 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
3073 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
3074 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
3075 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
3076 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
3077 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
3078 lv2_default = lilv_new_uri(world, LV2_CORE__default);
3079 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
3080 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
3081 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
3082 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
3083 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
3084 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
3085 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
3086 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
3087 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
3088 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
3089 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
3090 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
3091 time_Position = lilv_new_uri(world, LV2_TIME__Position);
3092 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
3093 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
3094 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
3095 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
3096 units_render = lilv_new_uri(world, LV2_UNITS__render);
3097 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
3098 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
3099 units_db = lilv_new_uri(world, LV2_UNITS__db);
3100 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
3101 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
3103 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls"); // deprecated 2016-09-18
3104 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
3105 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
3106 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
3107 auto_automation_controller = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
3109 #ifdef HAVE_LV2_1_2_0
3110 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
3111 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
3112 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
3113 bufz_coarseBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#coarseBlockLength");
3118 LV2World::~LV2World()
3123 #ifdef HAVE_LV2_1_2_0
3124 lilv_node_free(bufz_coarseBlockLength);
3125 lilv_node_free(bufz_nominalBlockLength);
3126 lilv_node_free(bufz_fixedBlockLength);
3127 lilv_node_free(bufz_powerOf2BlockLength);
3130 lilv_node_free(lv2_noSampleAccurateCtrl);
3131 lilv_node_free(auto_can_write_automatation);
3132 lilv_node_free(auto_automation_control);
3133 lilv_node_free(auto_automation_controlled);
3134 lilv_node_free(auto_automation_controller);
3136 lilv_node_free(patch_Message);
3137 lilv_node_free(patch_writable);
3138 lilv_node_free(units_hz);
3139 lilv_node_free(units_midiNote);
3140 lilv_node_free(units_db);
3141 lilv_node_free(units_unit);
3142 lilv_node_free(units_render);
3143 lilv_node_free(ui_externalkx);
3144 lilv_node_free(ui_external);
3145 lilv_node_free(ui_GtkUI);
3146 lilv_node_free(time_Position);
3147 lilv_node_free(rsz_minimumSize);
3148 lilv_node_free(rdfs_comment);
3149 lilv_node_free(rdfs_label);
3150 lilv_node_free(rdfs_range);
3151 lilv_node_free(midi_MidiEvent);
3152 lilv_node_free(lv2_enumeration);
3153 lilv_node_free(lv2_freewheeling);
3154 lilv_node_free(lv2_toggled);
3155 lilv_node_free(lv2_sampleRate);
3156 lilv_node_free(lv2_reportsLatency);
3157 lilv_node_free(lv2_integer);
3158 lilv_node_free(lv2_isSideChain);
3159 lilv_node_free(lv2_inPlaceBroken);
3160 lilv_node_free(lv2_OutputPort);
3161 lilv_node_free(lv2_InputPort);
3162 lilv_node_free(lv2_ControlPort);
3163 lilv_node_free(lv2_AudioPort);
3164 lilv_node_free(ext_rangeSteps);
3165 lilv_node_free(ext_notAutomatic);
3166 lilv_node_free(ext_causesArtifacts);
3167 lilv_node_free(ext_expensive);
3168 lilv_node_free(ext_notOnGUI);
3169 lilv_node_free(ext_logarithmic);
3170 lilv_node_free(ev_EventPort);
3171 lilv_node_free(atom_supports);
3172 lilv_node_free(atom_eventTransfer);
3173 lilv_node_free(atom_bufferType);
3174 lilv_node_free(atom_Sequence);
3175 lilv_node_free(atom_Chunk);
3176 lilv_node_free(atom_AtomPort);
3177 lilv_world_free(world);
3182 LV2World::load_bundled_plugins(bool verbose)
3184 if (!_bundle_checked) {
3186 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
3189 vector<string> plugin_objects;
3190 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
3191 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
3192 #ifdef PLATFORM_WINDOWS
3193 string uri = "file:///" + *x + "/";
3195 string uri = "file://" + *x + "/";
3197 LilvNode *node = lilv_new_uri(world, uri.c_str());
3198 lilv_world_load_bundle(world, node);
3199 lilv_node_free(node);
3202 lilv_world_load_all(world);
3203 _bundle_checked = true;
3207 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
3210 _plugin_uri = strdup(plugin_uri);
3213 LV2PluginInfo::~LV2PluginInfo()
3220 LV2PluginInfo::load(Session& session)
3224 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3225 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3226 if (!uri) { throw failed_constructor(); }
3227 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3228 if (!lp) { throw failed_constructor(); }
3229 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
3230 lilv_node_free(uri);
3231 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3233 } catch (failed_constructor& err) {
3234 return PluginPtr((Plugin*)0);
3240 std::vector<Plugin::PresetRecord>
3241 LV2PluginInfo::get_presets (bool /*user_only*/) const
3243 std::vector<Plugin::PresetRecord> p;
3244 #ifndef NO_PLUGIN_STATE
3245 const LilvPlugin* lp = NULL;
3248 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3249 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3250 if (!uri) { throw failed_constructor(); }
3251 lp = lilv_plugins_get_by_uri(plugins, uri);
3252 if (!lp) { throw failed_constructor(); }
3253 lilv_node_free(uri);
3254 } catch (failed_constructor& err) {
3258 // see LV2Plugin::find_presets
3259 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3260 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3261 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3263 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3264 LILV_FOREACH(nodes, i, presets) {
3265 const LilvNode* preset = lilv_nodes_get(presets, i);
3266 lilv_world_load_resource(_world.world, preset);
3267 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3268 bool userpreset = true; // TODO
3270 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
3271 lilv_node_free(name);
3274 lilv_nodes_free(presets);
3275 lilv_node_free(rdfs_label);
3276 lilv_node_free(pset_Preset);
3277 lilv_node_free(lv2_appliesTo);
3283 LV2PluginInfo::in_category (const std::string &c) const
3285 // TODO use untranslated lilv_plugin_get_class()
3286 // match gtk2_ardour/plugin_selector.cc
3287 if (category == c) {
3294 LV2PluginInfo::is_instrument () const
3296 if (category == "Instrument") {
3300 /* until we make sure that category remains untranslated in the lv2.ttl spec
3301 * and until most instruments also classify themselves as such, there's a 2nd check:
3303 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
3311 LV2PluginInfo::discover()
3314 world.load_bundled_plugins();
3315 _world.load_bundled_plugins(true);
3317 PluginInfoList* plugs = new PluginInfoList;
3318 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3320 LILV_FOREACH(plugins, i, plugins) {
3321 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3322 const LilvNode* pun = lilv_plugin_get_uri(p);
3324 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3326 LilvNode* name = lilv_plugin_get_name(p);
3327 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3328 warning << "Ignoring invalid LV2 plugin "
3329 << lilv_node_as_string(lilv_plugin_get_uri(p))
3334 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3335 warning << string_compose(
3336 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3337 lilv_node_as_string(name)) << endmsg;
3338 lilv_node_free(name);
3342 #ifdef HAVE_LV2_1_2_0
3343 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3344 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3345 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3347 warning << string_compose(
3348 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3349 lilv_node_as_string(name)) << endmsg;
3350 lilv_nodes_free(required_features);
3351 lilv_node_free(name);
3354 lilv_nodes_free(required_features);
3359 info->name = string(lilv_node_as_string(name));
3360 lilv_node_free(name);
3361 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3363 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3364 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3365 info->category = lilv_node_as_string(label);
3367 LilvNode* author_name = lilv_plugin_get_author_name(p);
3368 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3369 lilv_node_free(author_name);
3371 info->path = "/NOPATH"; // Meaningless for LV2
3373 /* count atom-event-ports that feature
3374 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3376 * TODO: nicely ask drobilla to make a lilv_ call for that
3378 int count_midi_out = 0;
3379 int count_midi_in = 0;
3380 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3381 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3382 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3383 LilvNodes* buffer_types = lilv_port_get_value(
3384 p, port, world.atom_bufferType);
3385 LilvNodes* atom_supports = lilv_port_get_value(
3386 p, port, world.atom_supports);
3388 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3389 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3390 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3393 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3397 lilv_nodes_free(buffer_types);
3398 lilv_nodes_free(atom_supports);
3402 info->n_inputs.set_audio(
3403 lilv_plugin_get_num_ports_of_class(
3404 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3405 info->n_inputs.set_midi(
3406 lilv_plugin_get_num_ports_of_class(
3407 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3410 info->n_outputs.set_audio(
3411 lilv_plugin_get_num_ports_of_class(
3412 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3413 info->n_outputs.set_midi(
3414 lilv_plugin_get_num_ports_of_class(
3415 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3418 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3419 info->index = 0; // Meaningless for LV2
3421 plugs->push_back(info);