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"
74 #include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
76 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
77 #include "lv2/lv2plug.in/ns/ext/options/options.h"
80 #include "lv2_evbuf.h"
83 #include <suil/suil.h>
86 // Compatibility for old LV2
87 #ifndef LV2_ATOM_CONTENTS_CONST
88 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
89 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
91 #ifndef LV2_ATOM_BODY_CONST
92 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
94 #ifndef LV2_PATCH__property
95 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
97 #ifndef LV2_PATCH__value
98 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
100 #ifndef LV2_PATCH__writable
101 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
104 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
105 This needs to be roughly the number of cycles the UI will get around to
106 actually processing the traffic. Lower values are flakier but save memory.
108 static const size_t NBUFS = 4;
111 using namespace ARDOUR;
114 bool LV2Plugin::force_state_save = false;
116 class LV2World : boost::noncopyable {
121 void load_bundled_plugins(bool verbose=false);
125 LilvNode* atom_AtomPort;
126 LilvNode* atom_Chunk;
127 LilvNode* atom_Sequence;
128 LilvNode* atom_bufferType;
129 LilvNode* atom_eventTransfer;
130 LilvNode* atom_supports;
131 LilvNode* ev_EventPort;
132 LilvNode* ext_logarithmic;
133 LilvNode* ext_notOnGUI;
134 LilvNode* ext_expensive;
135 LilvNode* ext_causesArtifacts;
136 LilvNode* ext_notAutomatic;
137 LilvNode* ext_rangeSteps;
138 LilvNode* groups_group;
139 LilvNode* groups_element;
140 LilvNode* lv2_AudioPort;
141 LilvNode* lv2_ControlPort;
142 LilvNode* lv2_InputPort;
143 LilvNode* lv2_OutputPort;
144 LilvNode* lv2_designation;
145 LilvNode* lv2_enumeration;
146 LilvNode* lv2_freewheeling;
147 LilvNode* lv2_inPlaceBroken;
148 LilvNode* lv2_isSideChain;
150 LilvNode* lv2_integer;
151 LilvNode* lv2_default;
152 LilvNode* lv2_minimum;
153 LilvNode* lv2_maximum;
154 LilvNode* lv2_reportsLatency;
155 LilvNode* lv2_sampleRate;
156 LilvNode* lv2_toggled;
157 LilvNode* midi_MidiEvent;
158 LilvNode* rdfs_comment;
159 LilvNode* rdfs_label;
160 LilvNode* rdfs_range;
161 LilvNode* rsz_minimumSize;
162 LilvNode* time_Position;
164 LilvNode* ui_external;
165 LilvNode* ui_externalkx;
168 LilvNode* units_unit;
169 LilvNode* units_render;
170 LilvNode* units_midiNote;
171 LilvNode* patch_writable;
172 LilvNode* patch_Message;
173 #ifdef HAVE_LV2_1_2_0
174 LilvNode* bufz_powerOf2BlockLength;
175 LilvNode* bufz_fixedBlockLength;
176 LilvNode* bufz_nominalBlockLength;
177 LilvNode* bufz_coarseBlockLength;
180 #ifdef HAVE_LV2_1_10_0
182 LilvNode* atom_float;
183 LilvNode* atom_object; // new in 1.8
184 LilvNode* atom_vector;
187 LilvNode* lv2_noSampleAccurateCtrl;
188 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
189 LilvNode* auto_automation_control; // atom:supports
190 LilvNode* auto_automation_controlled; // lv2:portProperty
191 LilvNode* auto_automation_controller; // lv2:portProperty
195 bool _bundle_checked;
198 static LV2World _world;
200 /* worker extension */
202 /** Called by the plugin to schedule non-RT work. */
203 static LV2_Worker_Status
204 work_schedule(LV2_Worker_Schedule_Handle handle,
208 return (((Worker*)handle)->schedule(size, data)
210 : LV2_WORKER_ERR_UNKNOWN);
213 /** Called by the plugin to respond to non-RT work. */
214 static LV2_Worker_Status
215 work_respond(LV2_Worker_Respond_Handle handle,
219 return (((Worker*)handle)->respond(size, data)
221 : LV2_WORKER_ERR_UNKNOWN);
225 /* inline display extension */
227 queue_draw (LV2_Inline_Display_Handle handle)
229 LV2Plugin* plugin = (LV2Plugin*)handle;
230 plugin->QueueDraw(); /* EMIT SIGNAL */
234 midnam_update (LV2_Midnam_Handle handle)
236 LV2Plugin* plugin = (LV2Plugin*)handle;
237 plugin->UpdateMidnam (); /* EMIT SIGNAL */
244 log_vprintf(LV2_Log_Handle /*handle*/,
250 const int ret = g_vasprintf(&str, fmt, args);
251 /* strip trailing whitespace */
252 while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
253 str[strlen (str) - 1] = '\0';
255 if (strlen (str) == 0) {
259 if (type == URIMap::instance().urids.log_Error) {
260 error << str << endmsg;
261 } else if (type == URIMap::instance().urids.log_Warning) {
262 warning << str << endmsg;
263 } else if (type == URIMap::instance().urids.log_Note) {
264 info << str << endmsg;
265 } else if (type == URIMap::instance().urids.log_Trace) {
266 DEBUG_TRACE(DEBUG::LV2, str);
272 log_printf(LV2_Log_Handle handle,
274 const char* fmt, ...)
278 const int ret = log_vprintf(handle, type, fmt, args);
283 struct LV2Plugin::Impl {
284 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
286 #ifdef HAVE_LV2_1_2_0
291 #ifdef HAVE_LV2_1_2_0
300 /** Find the LV2 input port with the given designation.
301 * If found, bufptrs[port_index] will be set to bufptr.
303 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
305 const LilvPlugin* plugin;
307 const LilvNode* ui_type;
310 LilvInstance* instance;
311 const LV2_Worker_Interface* work_iface;
312 #ifdef HAVE_LV2_1_2_0
313 const LV2_Options_Interface* opts_iface;
316 LV2_Atom_Forge forge;
317 LV2_Atom_Forge ui_forge;
318 int32_t block_length;
319 #ifdef HAVE_LV2_1_2_0
320 LV2_Options_Option* options;
323 LV2_Inline_Display* queue_draw;
328 LV2Plugin::LV2Plugin (AudioEngine& engine,
330 const void* c_plugin,
332 : Plugin (engine, session)
337 , _state_worker(NULL)
339 , _patch_port_in_index((uint32_t)-1)
340 , _patch_port_out_index((uint32_t)-1)
341 , _uri_map(URIMap::instance())
342 , _no_sample_accurate_ctrl (false)
344 init(c_plugin, rate);
347 LV2Plugin::LV2Plugin (const LV2Plugin& other)
353 , _state_worker(NULL)
354 , _insert_id(other._insert_id)
355 , _patch_port_in_index((uint32_t)-1)
356 , _patch_port_out_index((uint32_t)-1)
357 , _uri_map(URIMap::instance())
358 , _no_sample_accurate_ctrl (false)
360 init(other._impl->plugin, other._sample_rate);
362 for (uint32_t i = 0; i < parameter_count(); ++i) {
363 _control_data[i] = other._shadow_data[i];
364 _shadow_data[i] = other._shadow_data[i];
369 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
371 DEBUG_TRACE(DEBUG::LV2, "init\n");
373 _impl->plugin = (const LilvPlugin*)c_plugin;
375 _impl->ui_type = NULL;
380 _atom_ev_buffers = 0;
382 _bpm_control_port = 0;
383 _freewheel_control_port = 0;
384 _latency_control_port = 0;
385 _next_cycle_start = std::numeric_limits<framepos_t>::max();
386 _next_cycle_speed = 1.0;
387 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
389 _was_activated = false;
390 _has_state_interface = false;
391 _can_write_automation = false;
393 _current_latency = 0;
394 _impl->block_length = _session.get_block_size();
396 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
397 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
398 _make_path_feature.URI = LV2_STATE__makePath;
399 _log_feature.URI = LV2_LOG__log;
400 _work_schedule_feature.URI = LV2_WORKER__schedule;
401 _work_schedule_feature.data = NULL;
402 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
403 _def_state_feature.data = NULL;
405 const LilvPlugin* plugin = _impl->plugin;
407 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
408 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
409 _has_state_interface =
410 // What plugins should have (lv2:extensionData state:Interface)
411 lilv_plugin_has_extension_data(plugin, state_iface_uri)
412 // What some outdated/incorrect ones have
413 || lilv_plugin_has_feature(plugin, state_uri);
414 lilv_node_free(state_uri);
415 lilv_node_free(state_iface_uri);
417 _features = (LV2_Feature**)calloc(13, sizeof(LV2_Feature*));
418 _features[0] = &_instance_access_feature;
419 _features[1] = &_data_access_feature;
420 _features[2] = &_make_path_feature;
421 _features[3] = _uri_map.uri_map_feature();
422 _features[4] = _uri_map.urid_map_feature();
423 _features[5] = _uri_map.urid_unmap_feature();
424 _features[6] = &_log_feature;
426 unsigned n_features = 7;
427 #ifdef HAVE_LV2_1_2_0
428 _features[n_features++] = &_def_state_feature;
431 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
432 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
435 _impl->queue_draw = (LV2_Inline_Display*)
436 malloc (sizeof(LV2_Inline_Display));
437 _impl->queue_draw->handle = this;
438 _impl->queue_draw->queue_draw = queue_draw;
440 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
441 _queue_draw_feature.data = _impl->queue_draw;
442 _features[n_features++] = &_queue_draw_feature;
444 _impl->midnam = (LV2_Midnam*)
445 malloc (sizeof(LV2_Midnam));
446 _impl->midnam->handle = this;
447 _impl->midnam->update = midnam_update;
449 _midnam_feature.URI = LV2_MIDNAM__update;
450 _midnam_feature.data = _impl->midnam;
451 _features[n_features++] = &_midnam_feature;
454 #ifdef HAVE_LV2_1_2_0
455 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
456 static const int32_t _min_block_length = 1; // may happen during split-cycles
457 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
458 /* Consider updating max-block-size whenever the buffersize changes.
459 * It requires re-instantiating the plugin (which is a non-realtime operation),
460 * so it should be done lightly and only for plugins that require it.
462 * given that the block-size can change at any time (split-cycles) ardour currently
463 * does not support plugins that require bufz_fixedBlockLength.
465 LV2_Options_Option options[] = {
466 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
467 sizeof(int32_t), atom_Int, &_min_block_length },
468 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
469 sizeof(int32_t), atom_Int, &_max_block_length },
470 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
471 sizeof(int32_t), atom_Int, &_seq_size },
472 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
473 sizeof(int32_t), atom_Int, &_impl->block_length },
474 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
477 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
478 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
480 _options_feature.URI = LV2_OPTIONS__options;
481 _options_feature.data = _impl->options;
482 _features[n_features++] = &_options_feature;
485 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
486 sizeof(LV2_State_Make_Path));
487 make_path->handle = this;
488 make_path->path = &lv2_state_make_path;
489 _make_path_feature.data = make_path;
491 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
493 log->printf = &log_printf;
494 log->vprintf = &log_vprintf;
495 _log_feature.data = log;
497 const size_t ring_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
498 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
499 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
500 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
501 sizeof(LV2_Worker_Schedule));
502 _worker = new Worker(this, ring_size);
503 schedule->handle = _worker;
504 schedule->schedule_work = work_schedule;
505 _work_schedule_feature.data = schedule;
506 _features[n_features++] = &_work_schedule_feature;
508 lilv_node_free(worker_schedule);
510 if (_has_state_interface) {
511 // Create a non-threaded worker for use by state restore
512 _state_worker = new Worker(this, ring_size, false);
515 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
516 _impl->name = lilv_plugin_get_name(plugin);
517 _impl->author = lilv_plugin_get_author_name(plugin);
519 if (_impl->instance == 0) {
520 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
521 throw failed_constructor();
524 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
525 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
526 _data_access_feature.data = &_data_access_extension_data;
528 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
529 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
530 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
531 LV2_WORKER__interface);
533 lilv_node_free(worker_iface_uri);
536 #ifdef HAVE_LV2_1_2_0
537 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
538 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
539 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
540 LV2_OPTIONS__interface);
542 lilv_node_free(options_iface_uri);
546 _display_interface = (const LV2_Inline_Display_Interface*)
547 extension_data (LV2_INLINEDISPLAY__interface);
549 _midname_interface = (const LV2_Midnam_Interface*)
550 extension_data (LV2_MIDNAM__interface);
551 if (_midname_interface) {
556 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
557 error << string_compose(
558 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
559 lilv_node_as_string(_impl->name)) << endmsg;
560 lilv_node_free(_impl->name);
561 lilv_node_free(_impl->author);
562 throw failed_constructor();
565 #ifdef HAVE_LV2_1_2_0
566 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
567 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
568 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
570 error << string_compose(
571 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
572 lilv_node_as_string(_impl->name)) << endmsg;
573 lilv_node_free(_impl->name);
574 lilv_node_free(_impl->author);
575 lilv_nodes_free(required_features);
576 throw failed_constructor();
578 lilv_nodes_free(required_features);
581 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
582 #ifdef HAVE_LV2_1_2_0
583 if (lilv_nodes_contains (optional_features, _world.bufz_coarseBlockLength)) {
584 _no_sample_accurate_ctrl = true;
588 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
589 /* deprecated 2016-Sep-18 in favor of bufz_coarseBlockLength */
590 _no_sample_accurate_ctrl = true;
592 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
593 _can_write_automation = true;
595 lilv_nodes_free(optional_features);
598 #ifdef HAVE_LILV_0_16_0
599 // Load default state
601 /* immediately schedule any work,
602 * so that state restore later will not find a busy
603 * worker. latency_compute_run() flushes any replies
605 _worker->set_synchronous(true);
607 LilvState* state = lilv_state_new_from_world(
608 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
609 if (state && _has_state_interface) {
610 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
612 lilv_state_free(state);
617 const uint32_t num_ports = this->num_ports();
618 for (uint32_t i = 0; i < num_ports; ++i) {
619 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
621 size_t minimumSize = 0;
623 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
624 flags |= PORT_OUTPUT;
625 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
628 error << string_compose(
629 "LV2: \"%1\" port %2 is neither input nor output",
630 lilv_node_as_string(_impl->name), i) << endmsg;
631 throw failed_constructor();
634 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
635 flags |= PORT_CONTROL;
636 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
638 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
640 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
641 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
642 LilvNodes* buffer_types = lilv_port_get_value(
643 _impl->plugin, port, _world.atom_bufferType);
644 LilvNodes* atom_supports = lilv_port_get_value(
645 _impl->plugin, port, _world.atom_supports);
647 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
648 flags |= PORT_SEQUENCE;
649 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
652 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
653 flags |= PORT_POSITION;
656 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
657 flags |= PORT_AUTOCTRL;
660 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
661 flags |= PORT_PATCHMSG;
662 if (flags & PORT_INPUT) {
663 _patch_port_in_index = i;
665 _patch_port_out_index = i;
669 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
670 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
671 if (min_size && lilv_node_is_int(min_size)) {
672 minimumSize = lilv_node_as_int(min_size);
674 lilv_nodes_free(min_size_v);
675 lilv_nodes_free(buffer_types);
676 lilv_nodes_free(atom_supports);
678 error << string_compose(
679 "LV2: \"%1\" port %2 has no known data type",
680 lilv_node_as_string(_impl->name), i) << endmsg;
681 throw failed_constructor();
684 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
685 if (lilv_port_has_property(_impl->plugin, port, _world.ext_causesArtifacts)) {
686 flags |= PORT_NOAUTO;
688 if (lilv_port_has_property(_impl->plugin, port, _world.ext_notAutomatic)) {
689 flags |= PORT_NOAUTO;
691 if (lilv_port_has_property(_impl->plugin, port, _world.ext_expensive)) {
692 flags |= PORT_NOAUTO;
696 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
697 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
698 flags |= PORT_CTRLED;
701 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controller)) {
702 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
703 flags |= PORT_CTRLER;
708 _port_flags.push_back(flags);
709 _port_minimumSize.push_back(minimumSize);
710 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
713 _control_data = new float[num_ports];
714 _shadow_data = new float[num_ports];
715 _defaults = new float[num_ports];
716 _ev_buffers = new LV2_Evbuf*[num_ports];
717 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
719 const bool latent = lilv_plugin_has_latency(plugin);
720 const uint32_t latency_index = (latent)
721 ? lilv_plugin_get_latency_port_index(plugin)
724 // Build an array of pointers to special parameter buffers
725 void*** params = new void**[num_ports];
726 for (uint32_t i = 0; i < num_ports; ++i) {
729 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
730 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
732 for (uint32_t i = 0; i < num_ports; ++i) {
733 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
734 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
736 // Store index in map so we can look up index by symbol
737 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
739 // Get range and default value if applicable
740 if (parameter_is_control(i)) {
742 lilv_port_get_range(plugin, port, &def, NULL, NULL);
743 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
744 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
745 _defaults[i] *= _session.frame_rate ();
749 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
751 if (latent && i == latency_index) {
753 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
754 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
755 _latency_control_port = &_control_data[i];
756 *_latency_control_port = 0;
759 if (parameter_is_input(i)) {
760 _shadow_data[i] = default_value(i);
762 *params[i] = (void*)&_shadow_data[i];
772 LilvUIs* uis = lilv_plugin_get_uis(plugin);
773 if (lilv_uis_size(uis) > 0) {
775 // Look for embeddable UI
776 LILV_FOREACH(uis, u, uis) {
777 const LilvUI* this_ui = lilv_uis_get(uis, u);
778 const LilvNode* this_ui_type = NULL;
779 if (lilv_ui_is_supported(this_ui,
783 // TODO: Multiple UI support
785 _impl->ui_type = this_ui_type;
790 // Look for Gtk native UI
791 LILV_FOREACH(uis, i, uis) {
792 const LilvUI* ui = lilv_uis_get(uis, i);
793 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
795 _impl->ui_type = _world.ui_GtkUI;
801 // If Gtk UI is not available, try to find external UI
803 LILV_FOREACH(uis, i, uis) {
804 const LilvUI* ui = lilv_uis_get(uis, i);
805 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
807 _impl->ui_type = _world.ui_external;
810 if (lilv_ui_is_a(ui, _world.ui_external)) {
812 _impl->ui_type = _world.ui_external;
818 load_supported_properties(_property_descriptors);
819 allocate_atom_event_buffers();
820 latency_compute_run();
824 LV2Plugin::set_block_size (pframes_t nframes)
826 #ifdef HAVE_LV2_1_2_0
827 if (_impl->opts_iface) {
828 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
829 _impl->block_length = nframes;
830 LV2_Options_Option block_size_option = {
831 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
832 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
834 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
841 LV2Plugin::requires_fixed_sized_buffers () const
843 /* This controls if Ardour will split the plugin's run()
844 * on automation events in order to pass sample-accurate automation
845 * via standard control-ports.
847 * When returning true Ardour will *not* sub-divide the process-cycle.
848 * Automation events that happen between cycle-start and cycle-end will be
849 * ignored (ctrl values are interpolated to cycle-start).
850 * NB. Atom Sequences are still sample accurate.
852 * Note: This does not guarantee a fixed block-size.
853 * e.g The process cycle may be split when looping, also
854 * the period-size may change any time: see set_block_size()
856 if (get_info()->n_inputs.n_midi() > 0) {
857 /* we don't yet implement midi buffer offsets (for split cycles).
858 * Also connect_and_run() also uses _session.transport_frame() directly
859 * (for BBT) which is not offset for plugin cycle split.
863 return _no_sample_accurate_ctrl;
866 LV2Plugin::~LV2Plugin ()
868 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
875 std::stringstream ss;
878 MIDI::Name::MidiPatchManager::instance().remove_custom_midnam (ss.str());
882 lilv_instance_free(_impl->instance);
883 lilv_state_free(_impl->state);
884 lilv_node_free(_impl->name);
885 lilv_node_free(_impl->author);
886 #ifdef HAVE_LV2_1_2_0
887 free(_impl->options);
890 free(_impl->queue_draw);
895 free(_log_feature.data);
896 free(_make_path_feature.data);
897 free(_work_schedule_feature.data);
902 delete _state_worker;
904 if (_atom_ev_buffers) {
905 LV2_Evbuf** b = _atom_ev_buffers;
910 free(_atom_ev_buffers);
913 delete [] _control_data;
914 delete [] _shadow_data;
916 delete [] _ev_buffers;
921 LV2Plugin::is_external_ui() const
926 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
930 LV2Plugin::is_external_kx() const
935 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
939 LV2Plugin::ui_is_resizable () const
941 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
942 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
943 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
944 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
946 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
947 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
949 lilv_nodes_free(nrs_matches);
950 lilv_nodes_free(fs_matches);
955 return !fs_matches && !nrs_matches;
960 LV2Plugin::has_inline_display () {
961 return _display_interface ? true : false;
964 Plugin::Display_Image_Surface*
965 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
966 if (_display_interface) {
967 /* Plugin::Display_Image_Surface is identical to
968 * LV2_Inline_Display_Image_Surface */
969 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
975 LV2Plugin::has_midnam () {
976 return _midname_interface ? true : false;
980 LV2Plugin::read_midnam () {
982 if (!_midname_interface) {
985 char* midnam = _midname_interface->midnam ((void*)_impl->instance->lv2_handle);
987 std::stringstream ss;
990 rv = MIDI::Name::MidiPatchManager::instance().update_custom_midnam (ss.str(), midnam);
994 info << string_compose(_("LV2: update midnam for plugin '%1'"), name ()) << endmsg;
996 warning << string_compose(_("LV2: Failed to parse midnam of plugin '%1'"), name ()) << endmsg;
999 _midname_interface->free (midnam);
1004 LV2Plugin::midnam_model () {
1006 if (!_midname_interface) {
1009 char* model = _midname_interface->model ((void*)_impl->instance->lv2_handle);
1013 _midname_interface->free (model);
1019 LV2Plugin::unique_id() const
1021 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1025 LV2Plugin::uri() const
1027 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1031 LV2Plugin::label() const
1033 return lilv_node_as_string(_impl->name);
1037 LV2Plugin::name() const
1039 return lilv_node_as_string(_impl->name);
1043 LV2Plugin::maker() const
1045 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
1049 LV2Plugin::num_ports() const
1051 return lilv_plugin_get_num_ports(_impl->plugin);
1055 LV2Plugin::parameter_count() const
1057 return lilv_plugin_get_num_ports(_impl->plugin);
1061 LV2Plugin::default_value(uint32_t port)
1063 return _defaults[port];
1067 LV2Plugin::port_symbol(uint32_t index) const
1069 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
1071 error << name() << ": Invalid port index " << index << endmsg;
1074 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
1075 return lilv_node_as_string(sym);
1079 LV2Plugin::port_index (const char* symbol) const
1081 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
1082 if (i != _port_indices.end()) {
1085 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
1086 return (uint32_t)-1;
1091 LV2Plugin::set_parameter(uint32_t which, float val)
1093 DEBUG_TRACE(DEBUG::LV2, string_compose(
1094 "%1 set parameter %2 to %3\n", name(), which, val));
1096 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
1097 if (get_parameter (which) == val) {
1101 _shadow_data[which] = val;
1103 warning << string_compose(
1104 _("Illegal parameter number used with plugin \"%1\". "
1105 "This is a bug in either %2 or the LV2 plugin <%3>"),
1106 name(), PROGRAM_NAME, unique_id()) << endmsg;
1109 Plugin::set_parameter(which, val);
1113 LV2Plugin::get_parameter(uint32_t which) const
1115 if (parameter_is_input(which)) {
1116 return (float)_shadow_data[which];
1118 return (float)_control_data[which];
1124 LV2Plugin::get_docs() const
1126 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1128 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1129 lilv_nodes_free(comments);
1137 LV2Plugin::get_parameter_docs(uint32_t which) const
1139 LilvNodes* comments = lilv_port_get_value(
1141 lilv_plugin_get_port_by_index(_impl->plugin, which),
1142 _world.rdfs_comment);
1145 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1146 lilv_nodes_free(comments);
1154 LV2Plugin::get_layout (uint32_t which, UILayoutHint& h) const
1156 /// TODO lookup port-properties
1157 if (unique_id () != "urn:ardour:a-eq") {
1162 case 0: h.x0 = 0; h.x1 = 1; h.y0 = 2; h.y1 = 3; break; // Frequency L
1163 case 1: h.x0 = 0; h.x1 = 1; h.y0 = 0; h.y1 = 1; break; // Gain L
1164 case 17: h.x0 = 0; h.x1 = 1; h.y0 = 5; h.y1 = 6; break; // enable L
1166 case 2: h.x0 = 1; h.x1 = 3; h.y0 = 2; h.y1 = 3; break; // Frequency 1
1167 case 3: h.x0 = 1; h.x1 = 3; h.y0 = 0; h.y1 = 1; break; // Gain 1
1168 case 4: h.x0 = 2; h.x1 = 4; h.y0 = 1; h.y1 = 2; break; // Bandwidth 1
1169 case 18: h.x0 = 1; h.x1 = 4; h.y0 = 5; h.y1 = 6; break; // enable 1
1171 case 5: h.x0 = 4; h.x1 = 6; h.y0 = 2; h.y1 = 3; break; // Frequency 2
1172 case 6: h.x0 = 4; h.x1 = 6; h.y0 = 0; h.y1 = 1; break; // Gain 2
1173 case 7: h.x0 = 5; h.x1 = 7; h.y0 = 1; h.y1 = 2; break; // Bandwidth 2
1174 case 19: h.x0 = 4; h.x1 = 7; h.y0 = 5; h.y1 = 6; break; // enable 2
1176 case 8: h.x0 = 7; h.x1 = 9; h.y0 = 2; h.y1 = 3; break; // Frequency 3
1177 case 9: h.x0 = 7; h.x1 = 9; h.y0 = 0; h.y1 = 1; break; // Gain 3
1178 case 10: h.x0 = 8; h.x1 = 10; h.y0 = 1; h.y1 = 2; break; // Bandwidth 3
1179 case 20: h.x0 = 7; h.x1 = 10; h.y0 = 5; h.y1 = 6; break; // enable 3
1181 case 11: h.x0 = 10; h.x1 = 12; h.y0 = 2; h.y1 = 3; break; // Frequency 4
1182 case 12: h.x0 = 10; h.x1 = 12; h.y0 = 0; h.y1 = 1; break; // Gain 4
1183 case 13: h.x0 = 11; h.x1 = 13; h.y0 = 1; h.y1 = 2; break; // Bandwidth 4
1184 case 21: h.x0 = 10; h.x1 = 13; h.y0 = 5; h.y1 = 6; break; // enable 4
1186 case 14: h.x0 = 13; h.x1 = 14; h.y0 = 2; h.y1 = 3; break; // Frequency H
1187 case 15: h.x0 = 13; h.x1 = 14; h.y0 = 0; h.y1 = 1; break; // Gain H
1188 case 22: h.x0 = 13; h.x1 = 14; h.y0 = 5; h.y1 = 6; break; // enable H
1190 case 16: h.x0 = 14; h.x1 = 15; h.y0 = 1; h.y1 = 3; break; // Master Gain
1191 case 23: h.x0 = 14; h.x1 = 15; h.y0 = 5; h.y1 = 6; break; // Master Enable
1199 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1202 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1203 if (parameter_is_control(x)) {
1215 LV2Plugin::extension_data(const char* uri) const
1217 return lilv_instance_get_extension_data(_impl->instance, uri);
1221 LV2Plugin::c_plugin()
1223 return _impl->plugin;
1229 return (const void*)_impl->ui;
1233 LV2Plugin::c_ui_type()
1235 return (const void*)_impl->ui_type;
1238 /** Directory for all plugin state. */
1240 LV2Plugin::plugin_dir() const
1242 if (!_plugin_state_dir.empty ()){
1243 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1245 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1249 /** Directory for files created by the plugin (except during save). */
1251 LV2Plugin::scratch_dir() const
1253 return Glib::build_filename(plugin_dir(), "scratch");
1256 /** Directory for snapshots of files in the scratch directory. */
1258 LV2Plugin::file_dir() const
1260 return Glib::build_filename(plugin_dir(), "files");
1263 /** Directory to save state snapshot version @c num into. */
1265 LV2Plugin::state_dir(unsigned num) const
1267 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1270 /** Implementation of state:makePath for files created at instantiation time.
1271 * Note this is not used for files created at save time (Lilv deals with that).
1274 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1277 LV2Plugin* me = (LV2Plugin*)handle;
1278 if (me->_insert_id == PBD::ID("0")) {
1279 warning << string_compose(
1280 "File path \"%1\" requested but LV2 %2 has no insert ID",
1281 path, me->name()) << endmsg;
1282 return g_strdup(path);
1285 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1286 const std::string dirname = Glib::path_get_dirname(abs_path);
1287 g_mkdir_with_parents(dirname.c_str(), 0744);
1289 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1292 return g_strndup(abs_path.c_str(), abs_path.length());
1296 LV2Plugin::add_state(XMLNode* root) const
1298 assert(_insert_id != PBD::ID("0"));
1304 for (uint32_t i = 0; i < parameter_count(); ++i) {
1305 if (parameter_is_input(i) && parameter_is_control(i)) {
1306 child = new XMLNode("Port");
1307 child->add_property("symbol", port_symbol(i));
1308 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1309 child->add_property("value", string(buf));
1310 root->add_child_nocopy(*child);
1314 if (!_plugin_state_dir.empty()) {
1315 root->add_property("template-dir", _plugin_state_dir);
1318 if (_has_state_interface) {
1319 // Provisionally increment state version and create directory
1320 const std::string new_dir = state_dir(++_state_version);
1321 g_mkdir_with_parents(new_dir.c_str(), 0744);
1323 LilvState* state = lilv_state_new_from_instance(
1326 _uri_map.urid_map(),
1327 scratch_dir().c_str(),
1329 _session.externals_dir().c_str(),
1332 const_cast<LV2Plugin*>(this),
1336 if (!_plugin_state_dir.empty() || force_state_save
1338 || !lilv_state_equals(state, _impl->state)) {
1339 lilv_state_save(_world.world,
1340 _uri_map.urid_map(),
1341 _uri_map.urid_unmap(),
1347 if (force_state_save) {
1348 // archive or save-as
1349 lilv_state_free(state);
1352 else if (_plugin_state_dir.empty()) {
1353 // normal session save
1354 lilv_state_free(_impl->state);
1355 _impl->state = state;
1357 // template save (dedicated state-dir)
1358 lilv_state_free(state);
1362 // State is identical, decrement version and nuke directory
1363 lilv_state_free(state);
1364 PBD::remove_directory(new_dir);
1368 root->add_property("state-dir", string_compose("state%1", _state_version));
1372 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1374 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1376 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1378 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1379 lilv_nodes_free(vs);
1386 LV2Plugin::find_presets()
1388 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1389 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1390 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1392 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1393 LILV_FOREACH(nodes, i, presets) {
1394 const LilvNode* preset = lilv_nodes_get(presets, i);
1395 lilv_world_load_resource(_world.world, preset);
1396 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1397 bool userpreset = true; // TODO
1399 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1400 Plugin::PresetRecord(
1401 lilv_node_as_string(preset),
1402 lilv_node_as_string(name),
1404 lilv_node_free(name);
1406 warning << string_compose(
1407 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1408 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1409 lilv_node_as_string(preset)) << endmsg;
1412 lilv_nodes_free(presets);
1414 lilv_node_free(rdfs_label);
1415 lilv_node_free(pset_Preset);
1416 lilv_node_free(lv2_appliesTo);
1420 set_port_value(const char* port_symbol,
1426 LV2Plugin* self = (LV2Plugin*)user_data;
1427 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1428 return; // TODO: Support non-float ports
1431 const uint32_t port_index = self->port_index(port_symbol);
1432 if (port_index != (uint32_t)-1) {
1433 self->set_parameter(port_index, *(const float*)value);
1438 LV2Plugin::load_preset(PresetRecord r)
1440 LilvWorld* world = _world.world;
1441 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1442 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1444 const LV2_Feature* state_features[2] = { NULL, NULL };
1445 LV2_Worker_Schedule schedule = { _state_worker, work_schedule };
1446 const LV2_Feature state_sched_feature = { LV2_WORKER__schedule, &schedule };
1447 if (_state_worker) {
1448 state_features[0] = &state_sched_feature;
1452 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, state_features);
1453 lilv_state_free(state);
1454 Plugin::load_preset(r);
1457 lilv_node_free(pset);
1462 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1467 LV2Plugin *plugin = (LV2Plugin *) user_data;
1469 uint32_t index = plugin->port_index(port_symbol);
1470 if (index != (uint32_t) -1) {
1471 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1473 *size = sizeof(float);
1474 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1475 value = &plugin->_shadow_data[index];
1487 LV2Plugin::do_save_preset(string name)
1489 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1490 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1491 const string base_name = legalize_for_uri(name);
1492 const string file_name = base_name + ".ttl";
1493 const string bundle = Glib::build_filename(
1494 Glib::get_home_dir(),
1495 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1497 #ifdef HAVE_LILV_0_21_3
1498 /* delete reference to old preset (if any) */
1499 const PresetRecord* r = preset_by_label(name);
1501 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1503 lilv_world_unload_resource (_world.world, pset);
1504 lilv_node_free(pset);
1509 LilvState* state = lilv_state_new_from_instance(
1512 _uri_map.urid_map(),
1513 scratch_dir().c_str(), // file_dir
1514 bundle.c_str(), // copy_dir
1515 bundle.c_str(), // link_dir
1516 bundle.c_str(), // save_dir
1517 lv2plugin_get_port_value, // get_value
1518 (void*)this, // user_data
1519 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1520 _features // features
1523 lilv_state_set_label(state, name.c_str());
1525 _world.world, // world
1526 _uri_map.urid_map(), // map
1527 _uri_map.urid_unmap(), // unmap
1529 NULL, // uri (NULL = use file URI)
1530 bundle.c_str(), // dir
1531 file_name.c_str() // filename
1534 lilv_state_free(state);
1536 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1537 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1538 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1539 #ifdef HAVE_LILV_0_21_3
1540 lilv_world_unload_resource(_world.world, node_preset);
1541 lilv_world_unload_bundle(_world.world, node_bundle);
1543 lilv_world_load_bundle(_world.world, node_bundle);
1544 lilv_world_load_resource(_world.world, node_preset);
1545 lilv_node_free(node_bundle);
1546 lilv_node_free(node_preset);
1547 lilv_node_free(plug_name);
1552 LV2Plugin::do_remove_preset(string name)
1554 #ifdef HAVE_LILV_0_21_3
1555 /* Look up preset record by label (FIXME: ick, label as ID) */
1556 const PresetRecord* r = preset_by_label(name);
1561 /* Load a LilvState for the preset. */
1562 LilvWorld* world = _world.world;
1563 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1564 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1566 lilv_node_free(pset);
1570 /* Unload preset from world. */
1571 lilv_world_unload_resource(world, pset);
1573 /* Delete it from the file system. This will remove the preset file and the entry
1574 from the manifest. If this results in an empty manifest (i.e. the
1575 preset is the only thing in the bundle), then the bundle is removed. */
1576 lilv_state_delete(world, state);
1578 lilv_state_free(state);
1579 lilv_node_free(pset);
1581 /* Without lilv_state_delete(), we could delete the preset file, but this
1582 would leave a broken bundle/manifest around, so the preset would still
1583 be visible, but broken. Naively deleting a bundle is too dangerous, so
1584 we simply do not support preset deletion with older Lilv */
1588 LV2Plugin::has_editor() const
1590 return _impl->ui != NULL;
1594 LV2Plugin::has_message_output() const
1596 for (uint32_t i = 0; i < num_ports(); ++i) {
1597 if ((_port_flags[i] & PORT_SEQUENCE) &&
1598 (_port_flags[i] & PORT_OUTPUT)) {
1606 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1610 const uint8_t* body)
1612 const uint32_t buf_size = sizeof(UIMessage) + size;
1613 vector<uint8_t> buf(buf_size);
1615 UIMessage* msg = (UIMessage*)&buf[0];
1617 msg->protocol = protocol;
1619 memcpy(msg + 1, body, size);
1621 return (dest->write(&buf[0], buf_size) == buf_size);
1625 LV2Plugin::write_from_ui(uint32_t index,
1628 const uint8_t* body)
1631 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1632 /* buffer data communication from plugin UI to plugin instance.
1633 * this buffer needs to potentially hold
1634 * (port's minimumSize) * (audio-periods) / (UI-periods)
1637 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1638 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1639 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1641 * it is NOT safe to overflow (msg.size will be misinterpreted)
1643 uint32_t bufsiz = 32768;
1644 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1645 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1647 rbs = max((size_t) bufsiz * 8, rbs);
1648 _from_ui = new RingBuffer<uint8_t>(rbs);
1651 if (!write_to(_from_ui, index, protocol, size, body)) {
1652 error << "Error writing from UI to plugin" << endmsg;
1659 LV2Plugin::write_to_ui(uint32_t index,
1662 const uint8_t* body)
1664 if (!write_to(_to_ui, index, protocol, size, body)) {
1665 error << "Error writing from plugin to UI" << endmsg;
1672 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1674 switch (value.type()) {
1675 case Variant::NOTHING:
1677 case Variant::BEATS:
1678 // No atom type for this, just forge a double
1679 lv2_atom_forge_double(forge, value.get_beats().to_double());
1682 lv2_atom_forge_bool(forge, value.get_bool());
1684 case Variant::DOUBLE:
1685 lv2_atom_forge_double(forge, value.get_double());
1687 case Variant::FLOAT:
1688 lv2_atom_forge_float(forge, value.get_float());
1691 lv2_atom_forge_int(forge, value.get_int());
1694 lv2_atom_forge_long(forge, value.get_long());
1697 lv2_atom_forge_path(
1698 forge, value.get_path().c_str(), value.get_path().size());
1700 case Variant::STRING:
1701 lv2_atom_forge_string(
1702 forge, value.get_string().c_str(), value.get_string().size());
1706 forge, value.get_uri().c_str(), value.get_uri().size());
1711 /** Get a variant type from a URI, return false iff no match found. */
1713 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1715 if (uri == LV2_ATOM__Bool) {
1716 type = Variant::BOOL;
1717 } else if (uri == LV2_ATOM__Double) {
1718 type = Variant::DOUBLE;
1719 } else if (uri == LV2_ATOM__Float) {
1720 type = Variant::FLOAT;
1721 } else if (uri == LV2_ATOM__Int) {
1722 type = Variant::INT;
1723 } else if (uri == LV2_ATOM__Long) {
1724 type = Variant::LONG;
1725 } else if (uri == LV2_ATOM__Path) {
1726 type = Variant::PATH;
1727 } else if (uri == LV2_ATOM__String) {
1728 type = Variant::STRING;
1729 } else if (uri == LV2_ATOM__URI) {
1730 type = Variant::URI;
1738 LV2Plugin::set_property(uint32_t key, const Variant& value)
1740 if (_patch_port_in_index == (uint32_t)-1) {
1741 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1743 } else if (value.type() == Variant::NOTHING) {
1744 error << "LV2: set_property called with void value" << endmsg;
1748 // Set up forge to write to temporary buffer on the stack
1749 LV2_Atom_Forge* forge = &_impl->ui_forge;
1750 LV2_Atom_Forge_Frame frame;
1751 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1753 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1755 // Serialize patch:Set message to set property
1756 #ifdef HAVE_LV2_1_10_0
1757 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1758 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1759 lv2_atom_forge_urid(forge, key);
1760 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1762 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1763 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1764 lv2_atom_forge_urid(forge, key);
1765 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1768 forge_variant(forge, value);
1770 // Write message to UI=>Plugin ring
1771 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1772 write_from_ui(_patch_port_in_index,
1773 _uri_map.urids.atom_eventTransfer,
1774 lv2_atom_total_size(atom),
1775 (const uint8_t*)atom);
1778 const ParameterDescriptor&
1779 LV2Plugin::get_property_descriptor(uint32_t id) const
1781 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1782 if (p != _property_descriptors.end()) {
1785 return Plugin::get_property_descriptor(id);
1789 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1791 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1792 desc.unit = ParameterDescriptor::MIDI_NOTE;
1793 } else if (lilv_nodes_contains(units, _world.units_db)) {
1794 desc.unit = ParameterDescriptor::DB;
1795 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1796 desc.unit = ParameterDescriptor::HZ;
1798 if (lilv_nodes_size(units) > 0) {
1799 const LilvNode* unit = lilv_nodes_get_first(units);
1800 LilvNode* render = get_value(lworld, unit, _world.units_render);
1802 desc.print_fmt = lilv_node_as_string(render);
1803 replace_all (desc.print_fmt, "%f", "%.2f");
1804 lilv_node_free(render);
1810 load_parameter_descriptor(LV2World& world,
1811 ParameterDescriptor& desc,
1812 Variant::Type datatype,
1813 const LilvNode* subject)
1815 LilvWorld* lworld = _world.world;
1816 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1817 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1818 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1819 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1820 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1822 desc.label = lilv_node_as_string(label);
1824 if (def && lilv_node_is_float(def)) {
1825 desc.normal = lilv_node_as_float(def);
1827 if (minimum && lilv_node_is_float(minimum)) {
1828 desc.lower = lilv_node_as_float(minimum);
1830 if (maximum && lilv_node_is_float(maximum)) {
1831 desc.upper = lilv_node_as_float(maximum);
1833 load_parameter_descriptor_units(lworld, desc, units);
1834 desc.datatype = datatype;
1835 desc.toggled |= datatype == Variant::BOOL;
1836 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1837 desc.update_steps();
1839 lilv_nodes_free(units);
1840 lilv_node_free(label);
1841 lilv_node_free(def);
1842 lilv_node_free(minimum);
1843 lilv_node_free(maximum);
1847 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1849 LilvWorld* lworld = _world.world;
1850 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1851 LilvNodes* properties = lilv_world_find_nodes(
1852 lworld, subject, _world.patch_writable, NULL);
1853 LILV_FOREACH(nodes, p, properties) {
1854 // Get label and range
1855 const LilvNode* prop = lilv_nodes_get(properties, p);
1856 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1858 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1859 lilv_node_as_uri(prop)) << endmsg;
1863 // Convert range to variant type (TODO: support for multiple range types)
1864 Variant::Type datatype;
1865 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1866 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1867 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1871 // Add description to result
1872 ParameterDescriptor desc;
1873 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1874 desc.datatype = datatype;
1875 load_parameter_descriptor(_world, desc, datatype, prop);
1876 descs.insert(std::make_pair(desc.key, desc));
1878 lilv_node_free(range);
1880 lilv_nodes_free(properties);
1884 LV2Plugin::announce_property_values()
1886 if (_patch_port_in_index == (uint32_t)-1) {
1890 // Set up forge to write to temporary buffer on the stack
1891 LV2_Atom_Forge* forge = &_impl->ui_forge;
1892 LV2_Atom_Forge_Frame frame;
1893 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1895 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1897 // Serialize patch:Get message with no subject (implicitly plugin instance)
1898 #ifdef HAVE_LV2_1_10_0
1899 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1901 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1904 // Write message to UI=>Plugin ring
1905 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1906 write_from_ui(_patch_port_in_index,
1907 _uri_map.urids.atom_eventTransfer,
1908 lv2_atom_total_size(atom),
1909 (const uint8_t*)atom);
1913 LV2Plugin::enable_ui_emission()
1916 /* see note in LV2Plugin::write_from_ui() */
1917 uint32_t bufsiz = 32768;
1918 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1919 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1921 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1922 rbs = max((size_t) bufsiz * 8, rbs);
1923 _to_ui = new RingBuffer<uint8_t>(rbs);
1928 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1934 uint32_t read_space = _to_ui->read_space();
1935 while (read_space > sizeof(UIMessage)) {
1937 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1938 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1941 vector<uint8_t> body(msg.size);
1942 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1943 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1947 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1949 read_space -= sizeof(msg) + msg.size;
1954 LV2Plugin::work(Worker& worker, uint32_t size, const void* data)
1956 Glib::Threads::Mutex::Lock lm(_work_mutex);
1957 return _impl->work_iface->work(
1958 _impl->instance->lv2_handle, work_respond, &worker, size, data);
1962 LV2Plugin::work_response(uint32_t size, const void* data)
1964 return _impl->work_iface->work_response(
1965 _impl->instance->lv2_handle, size, data);
1969 LV2Plugin::set_insert_id(PBD::ID id)
1971 if (_insert_id == "0") {
1973 } else if (_insert_id != id) {
1974 lilv_state_free(_impl->state);
1975 _impl->state = NULL;
1981 LV2Plugin::set_state_dir (const std::string& d)
1983 _plugin_state_dir = d;
1987 LV2Plugin::set_state(const XMLNode& node, int version)
1990 XMLProperty const * prop;
1991 XMLNodeConstIterator iter;
1998 if (node.name() != state_node_name()) {
1999 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
2003 #ifndef NO_PLUGIN_STATE
2005 if (version < 3000) {
2006 nodes = node.children("port");
2008 nodes = node.children("Port");
2011 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
2015 if ((prop = child->property("symbol")) != 0) {
2016 sym = prop->value().c_str();
2018 warning << _("LV2: port has no symbol, ignored") << endmsg;
2022 map<string, uint32_t>::iterator i = _port_indices.find(sym);
2024 if (i != _port_indices.end()) {
2025 port_id = i->second;
2027 warning << _("LV2: port has unknown index, ignored") << endmsg;
2031 if ((prop = child->property("value")) != 0) {
2032 value = prop->value().c_str();
2034 warning << _("LV2: port has no value, ignored") << endmsg;
2038 set_parameter(port_id, atof(value));
2041 if ((prop = node.property("template-dir")) != 0) {
2042 set_state_dir (prop->value ());
2046 if ((prop = node.property("state-dir")) != 0) {
2047 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
2048 error << string_compose(
2049 "LV2: failed to parse state version from \"%1\"",
2050 prop->value()) << endmsg;
2053 std::string state_file = Glib::build_filename(
2055 Glib::build_filename(prop->value(), "state.ttl"));
2057 LilvState* state = lilv_state_new_from_file(
2058 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
2060 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
2061 lilv_state_free(_impl->state);
2062 _impl->state = state;
2065 if (!_plugin_state_dir.empty ()) {
2066 // force save with session, next time (increment counter)
2067 lilv_state_free (_impl->state);
2068 _impl->state = NULL;
2072 latency_compute_run();
2075 return Plugin::set_state(node, version);
2079 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
2081 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
2083 error << string_compose("LV2: get descriptor of non-existent port %1", which)
2088 LilvNodes* portunits;
2089 LilvNode *def, *min, *max;
2090 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
2091 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
2093 LilvNode* steps = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
2095 // TODO: Once we can rely on lilv 0.18.0 being present,
2096 // load_parameter_descriptor() can be used for ports as well
2097 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
2098 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
2099 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
2100 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
2101 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
2102 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
2103 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
2104 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
2105 load_parameter_descriptor_units(_world.world, desc, portunits);
2107 if (desc.sr_dependent) {
2108 desc.lower *= _session.frame_rate ();
2109 desc.upper *= _session.frame_rate ();
2112 desc.min_unbound = false; // TODO: LV2 extension required
2113 desc.max_unbound = false; // TODO: LV2 extension required
2115 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
2116 desc.scale_points = get_scale_points(which);
2118 desc.update_steps();
2121 //override auto-calculated steps in update_steps()
2122 float s = lilv_node_as_float (steps);
2123 const float delta = desc.upper - desc.lower;
2125 desc.step = desc.smallstep = (delta / s);
2126 desc.largestep = std::min ((delta / 5.0f), 10.f * desc.smallstep);
2128 if (desc.logarithmic) {
2129 // TODO marry AutomationControl::internal_to_interface () with
2130 // http://lv2plug.in/ns/ext/port-props/#rangeSteps
2131 desc.smallstep = desc.smallstep / logf(s);
2132 desc.step = desc.step / logf(s);
2133 desc.largestep = desc.largestep / logf(s);
2134 } else if (desc.integer_step) {
2135 desc.smallstep = 1.0;
2136 desc.step = std::max(1.f, rintf (desc.step));
2137 desc.largestep = std::max(1.f, rintf (desc.largestep));
2139 DEBUG_TRACE(DEBUG::LV2, string_compose("parameter %1 small: %2, step: %3 largestep: %4\n",
2140 which, desc.smallstep, desc.step, desc.largestep));
2144 lilv_node_free(def);
2145 lilv_node_free(min);
2146 lilv_node_free(max);
2147 lilv_node_free(steps);
2148 lilv_nodes_free(portunits);
2153 Plugin::IOPortDescription
2154 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2156 PortFlags match = 0;
2158 case DataType::AUDIO:
2161 case DataType::MIDI:
2162 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2165 return Plugin::IOPortDescription ("?");
2169 match |= PORT_INPUT;
2171 match |= PORT_OUTPUT;
2175 uint32_t idx = UINT32_MAX;
2177 uint32_t const num_ports = parameter_count();
2178 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2179 PortFlags flags = _port_flags[port_index];
2180 if ((flags & match) == match) {
2187 if (idx == UINT32_MAX) {
2188 return Plugin::IOPortDescription ("?");
2191 const LilvPort* pport = lilv_plugin_get_port_by_index (_impl->plugin, idx);
2193 LilvNode* name = lilv_port_get_name(_impl->plugin, pport);
2194 Plugin::IOPortDescription iod (lilv_node_as_string (name));
2195 lilv_node_free(name);
2197 /* get the port's pg:group */
2198 LilvNodes* groups = lilv_port_get_value (_impl->plugin, pport, _world.groups_group);
2199 if (lilv_nodes_size (groups) > 0) {
2200 const LilvNode* group = lilv_nodes_get_first (groups);
2201 LilvNodes* grouplabel = lilv_world_find_nodes (_world.world, group, _world.rdfs_label, NULL);
2203 /* get the name of the port-group */
2204 if (lilv_nodes_size (grouplabel) > 0) {
2205 const LilvNode* grpname = lilv_nodes_get_first (grouplabel);
2206 iod.group_name = lilv_node_as_string (grpname);
2208 lilv_nodes_free (grouplabel);
2210 /* get all port designations.
2211 * we're interested in e.g. lv2:designation pg:right */
2212 LilvNodes* designations = lilv_port_get_value (_impl->plugin, pport, _world.lv2_designation);
2213 if (lilv_nodes_size (designations) > 0) {
2214 /* get all pg:elements of the pg:group */
2215 LilvNodes* group_childs = lilv_world_find_nodes (_world.world, group, _world.groups_element, NULL);
2216 if (lilv_nodes_size (group_childs) > 0) {
2217 /* iterate over all port designations .. */
2218 LILV_FOREACH (nodes, i, designations) {
2219 const LilvNode* designation = lilv_nodes_get (designations, i);
2220 /* match the lv2:designation's element against the port-group's element */
2221 LILV_FOREACH (nodes, j, group_childs) {
2222 const LilvNode* group_element = lilv_nodes_get (group_childs, j);
2223 LilvNodes* elem = lilv_world_find_nodes (_world.world, group_element, _world.lv2_designation, designation);
2224 /* found it. Now look up the index (channel-number) of the pg:Element */
2225 if (lilv_nodes_size (elem) > 0) {
2226 LilvNodes* idx = lilv_world_find_nodes (_world.world, lilv_nodes_get_first (elem), _world.lv2_index, NULL);
2227 if (lilv_node_is_int (lilv_nodes_get_first (idx))) {
2228 iod.group_channel = lilv_node_as_int(lilv_nodes_get_first (idx));
2235 lilv_nodes_free (groups);
2236 lilv_nodes_free (designations);
2239 if (lilv_port_has_property(_impl->plugin, pport, _world.lv2_isSideChain)) {
2240 iod.is_sidechain = true;
2246 LV2Plugin::describe_parameter(Evoral::Parameter which)
2248 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2250 if (lilv_port_has_property(_impl->plugin,
2251 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2252 return X_("hidden");
2255 if (lilv_port_has_property(_impl->plugin,
2256 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2257 return X_("hidden");
2260 if (lilv_port_has_property(_impl->plugin,
2261 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2262 return X_("latency");
2265 LilvNode* name = lilv_port_get_name(_impl->plugin,
2266 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2267 string ret(lilv_node_as_string(name));
2268 lilv_node_free(name);
2276 LV2Plugin::max_latency () const
2278 return _max_latency;
2282 LV2Plugin::signal_latency() const
2284 if (_latency_control_port) {
2285 return (framecnt_t)floor(*_latency_control_port);
2291 set<Evoral::Parameter>
2292 LV2Plugin::automatable() const
2294 set<Evoral::Parameter> ret;
2296 for (uint32_t i = 0; i < parameter_count(); ++i) {
2297 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2298 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2302 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2303 p != _property_descriptors.end();
2305 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2311 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2313 if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2314 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2315 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2319 LV2Plugin::AutomationCtrlPtr
2320 LV2Plugin::get_automation_control (uint32_t i)
2322 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2323 return AutomationCtrlPtr ();
2325 return _ctrl_map[i];
2329 LV2Plugin::activate()
2331 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2333 if (!_was_activated) {
2334 lilv_instance_activate(_impl->instance);
2335 _was_activated = true;
2340 LV2Plugin::deactivate()
2342 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2344 if (_was_activated) {
2345 lilv_instance_deactivate(_impl->instance);
2346 _was_activated = false;
2351 LV2Plugin::cleanup()
2353 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2356 lilv_instance_free(_impl->instance);
2357 _impl->instance = NULL;
2361 LV2Plugin::allocate_atom_event_buffers()
2363 /* reserve local scratch buffers for ATOM event-queues */
2364 const LilvPlugin* p = _impl->plugin;
2366 /* count non-MIDI atom event-ports
2367 * TODO: nicely ask drobilla to make a lilv_ call for that
2369 int count_atom_out = 0;
2370 int count_atom_in = 0;
2371 int minimumSize = 32768; // TODO use a per-port minimum-size
2372 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2373 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2374 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2375 LilvNodes* buffer_types = lilv_port_get_value(
2376 p, port, _world.atom_bufferType);
2377 LilvNodes* atom_supports = lilv_port_get_value(
2378 p, port, _world.atom_supports);
2380 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2381 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2384 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2387 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2388 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2389 if (min_size && lilv_node_is_int(min_size)) {
2390 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2392 lilv_nodes_free(min_size_v);
2394 lilv_nodes_free(buffer_types);
2395 lilv_nodes_free(atom_supports);
2399 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2400 name(), count_atom_in, count_atom_out));
2402 const int total_atom_buffers = (count_atom_in + count_atom_out);
2403 if (_atom_ev_buffers || total_atom_buffers == 0) {
2407 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2408 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2409 for (int i = 0; i < total_atom_buffers; ++i ) {
2410 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2411 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2413 _atom_ev_buffers[total_atom_buffers] = 0;
2417 /** Write an ardour position/time/tempo/meter as an LV2 event.
2418 * @return true on success.
2421 write_position(LV2_Atom_Forge* forge,
2423 const TempoMetric& t,
2424 Timecode::BBT_Time& bbt,
2427 framepos_t position,
2430 const URIMap::URIDs& urids = URIMap::instance().urids;
2432 uint8_t pos_buf[256];
2433 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2434 LV2_Atom_Forge_Frame frame;
2435 #ifdef HAVE_LV2_1_10_0
2436 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2437 lv2_atom_forge_key(forge, urids.time_frame);
2438 lv2_atom_forge_long(forge, position);
2439 lv2_atom_forge_key(forge, urids.time_speed);
2440 lv2_atom_forge_float(forge, speed);
2441 lv2_atom_forge_key(forge, urids.time_barBeat);
2442 lv2_atom_forge_float(forge, bbt.beats - 1 +
2443 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2444 lv2_atom_forge_key(forge, urids.time_bar);
2445 lv2_atom_forge_long(forge, bbt.bars - 1);
2446 lv2_atom_forge_key(forge, urids.time_beatUnit);
2447 lv2_atom_forge_int(forge, t.meter().note_divisor());
2448 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2449 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2450 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2451 lv2_atom_forge_float(forge, bpm);
2453 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2454 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2455 lv2_atom_forge_long(forge, position);
2456 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2457 lv2_atom_forge_float(forge, speed);
2458 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2459 lv2_atom_forge_float(forge, bbt.beats - 1 +
2460 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2461 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2462 lv2_atom_forge_long(forge, bbt.bars - 1);
2463 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2464 lv2_atom_forge_int(forge, t.meter().note_divisor());
2465 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2466 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2467 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2468 lv2_atom_forge_float(forge, bpm);
2471 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2472 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2473 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2474 (const uint8_t*)(atom + 1));
2478 LV2Plugin::connect_and_run(BufferSet& bufs,
2479 framepos_t start, framepos_t end, double speed,
2480 ChanMapping in_map, ChanMapping out_map,
2481 pframes_t nframes, framecnt_t offset)
2483 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2484 Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2486 cycles_t then = get_cycles();
2488 TempoMap& tmap = _session.tempo_map();
2489 Metrics::const_iterator metric_i = tmap.metrics_end();
2490 TempoMetric tmetric = tmap.metric_at(start, &metric_i);
2492 if (_freewheel_control_port) {
2493 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2496 if (_bpm_control_port) {
2497 *_bpm_control_port = tmap.tempo_at_frame (start).beats_per_minute();
2501 if (_can_write_automation && start != _next_cycle_start) {
2502 // add guard-points after locating
2503 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2504 i->second->guard = true;
2509 ChanCount bufs_count;
2510 bufs_count.set(DataType::AUDIO, 1);
2511 bufs_count.set(DataType::MIDI, 1);
2512 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2513 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2514 uint32_t const num_ports = parameter_count();
2515 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2517 uint32_t audio_in_index = 0;
2518 uint32_t audio_out_index = 0;
2519 uint32_t midi_in_index = 0;
2520 uint32_t midi_out_index = 0;
2521 uint32_t atom_port_index = 0;
2522 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2524 uint32_t index = nil_index;
2525 PortFlags flags = _port_flags[port_index];
2527 if (flags & PORT_AUDIO) {
2528 if (flags & PORT_INPUT) {
2529 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2531 ? bufs.get_audio(index).data(offset)
2532 : silent_bufs.get_audio(0).data(offset);
2534 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2536 ? bufs.get_audio(index).data(offset)
2537 : scratch_bufs.get_audio(0).data(offset);
2539 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2540 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2541 be necessary, but the mapping is illegal in some cases. Ideally
2542 that should be fixed, but this is easier...
2544 if (flags & PORT_MIDI) {
2545 if (flags & PORT_INPUT) {
2546 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2548 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2550 if (valid && bufs.count().n_midi() > index) {
2551 /* Note, ensure_lv2_bufsize() is not RT safe!
2552 * However free()/alloc() is only called if a
2553 * plugin requires a rsz:minimumSize buffersize
2554 * and the existing buffer if smaller.
2556 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2557 _ev_buffers[port_index] = bufs.get_lv2_midi(
2558 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2560 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2561 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2562 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2566 if (valid && (flags & PORT_INPUT)) {
2567 if ((flags & PORT_POSITION)) {
2568 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2569 double bpm = tmap.tempo_at_frame (start).beats_per_minute();
2570 double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
2572 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2573 beatpos *= tmetric.meter().note_divisor() / 4.0;
2574 if (start != _next_cycle_start ||
2575 speed != _next_cycle_speed ||
2576 rint (1000 * beatpos) != rint(1000 * _next_cycle_beat) ||
2577 bpm != _current_bpm) {
2578 // Transport or Tempo has changed, write position at cycle start
2579 write_position(&_impl->forge, _ev_buffers[port_index],
2580 tmetric, bbt, speed, bpm, start, 0);
2584 // Get MIDI iterator range (empty range if no MIDI)
2585 MidiBuffer::iterator m = (index != nil_index)
2586 ? bufs.get_midi(index).begin()
2587 : silent_bufs.get_midi(0).end();
2588 MidiBuffer::iterator m_end = (index != nil_index)
2589 ? bufs.get_midi(index).end()
2592 // Now merge MIDI and any transport events into the buffer
2593 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2594 const framepos_t tend = end;
2596 while (m != m_end || (metric_i != tmap.metrics_end() &&
2597 (*metric_i)->frame() < tend)) {
2598 MetricSection* metric = (metric_i != tmap.metrics_end())
2600 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2601 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2602 if (ev.time() < nframes) {
2603 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2604 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2608 tmetric.set_metric(metric);
2609 Timecode::BBT_Time bbt;
2610 bbt = tmap.bbt_at_frame (metric->frame());
2611 double bpm = tmap.tempo_at_frame (start/*XXX*/).beats_per_minute();
2612 write_position(&_impl->forge, _ev_buffers[port_index],
2613 tmetric, bbt, speed, bpm,
2615 metric->frame() - start);
2619 } else if (!valid) {
2620 // Nothing we understand or care about, connect to scratch
2621 // see note for midi-buffer size above
2622 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2623 0, _port_minimumSize[port_index]);
2624 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2625 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2628 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2630 continue; // Control port, leave buffer alone
2632 lilv_instance_connect_port(_impl->instance, port_index, buf);
2635 // Read messages from UI and push into appropriate buffers
2637 uint32_t read_space = _from_ui->read_space();
2638 while (read_space > sizeof(UIMessage)) {
2640 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2641 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2644 vector<uint8_t> body(msg.size);
2645 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2646 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2649 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2650 LV2_Evbuf* buf = _ev_buffers[msg.index];
2651 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2652 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2653 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2654 (const uint8_t*)(atom + 1))) {
2655 error << "Failed to write data to LV2 event buffer\n";
2658 error << "Received unknown message type from UI" << endmsg;
2660 read_space -= sizeof(UIMessage) + msg.size;
2667 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2668 PortFlags flags = _port_flags[port_index];
2671 /* TODO ask drobilla about comment
2672 * "Make Ardour event buffers generic so plugins can communicate"
2673 * in libs/ardour/buffer_set.cc:310
2675 * ideally the user could choose which of the following two modes
2676 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2678 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2679 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2680 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2681 * for quite a while at least ;)
2683 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2684 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2685 const uint32_t buf_index = out_map.get(
2686 DataType::MIDI, midi_out_index++, &valid);
2688 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2691 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2692 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2693 const uint32_t buf_index = out_map.get(
2694 DataType::MIDI, midi_out_index++, &valid);
2696 bufs.flush_lv2_midi(true, buf_index);
2700 // Write messages to UI
2701 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2702 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2703 LV2_Evbuf* buf = _ev_buffers[port_index];
2704 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2705 lv2_evbuf_is_valid(i);
2706 i = lv2_evbuf_next(i)) {
2707 uint32_t frames, subframes, type, size;
2709 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2712 // Intercept Automation Write Events
2713 if ((flags & PORT_AUTOCTRL)) {
2714 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2715 if (atom->type == _uri_map.urids.atom_Blank ||
2716 atom->type == _uri_map.urids.atom_Object) {
2717 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2718 if (obj->body.otype == _uri_map.urids.auto_event) {
2719 // only if transport_rolling ??
2720 const LV2_Atom* parameter = NULL;
2721 const LV2_Atom* value = NULL;
2722 lv2_atom_object_get(obj,
2723 _uri_map.urids.auto_parameter, ¶meter,
2724 _uri_map.urids.auto_value, &value,
2726 if (parameter && value) {
2727 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2728 const float v = ((const LV2_Atom_Float*)value)->body;
2729 // -> add automation event..
2730 DEBUG_TRACE(DEBUG::LV2Automate,
2731 string_compose ("Event p: %1 t: %2 v: %3\n", p, frames, v));
2732 AutomationCtrlPtr c = get_automation_control (p);
2734 (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2736 framepos_t when = std::max ((framepos_t) 0, start + frames - _current_latency);
2737 assert (start + frames - _current_latency >= 0);
2740 c->ac->list()->add (when, v, true, true);
2742 c->ac->set_double (v, when, true);
2747 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2748 // TODO optional arguments, for now we assume the plugin
2749 // writes automation for its own inputs
2750 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2751 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2752 if (_port_flags[i->first] & PORT_CTRLED) {
2753 DEBUG_TRACE(DEBUG::LV2Automate,
2754 string_compose ("Setup p: %1\n", i->first));
2755 i->second->ac->set_automation_state (Touch);
2759 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2760 // set [touched] parameters to "play" ??
2761 // allow plugin to change its mode (from analyze to apply)
2762 const LV2_Atom* parameter = NULL;
2763 const LV2_Atom* value = NULL;
2764 lv2_atom_object_get(obj,
2765 _uri_map.urids.auto_parameter, ¶meter,
2766 _uri_map.urids.auto_value, &value,
2768 if (parameter && value) {
2769 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2770 const float v = ((const LV2_Atom_Float*)value)->body;
2771 AutomationCtrlPtr c = get_automation_control (p);
2772 DEBUG_TRACE(DEBUG::LV2Automate,
2773 string_compose ("Finalize p: %1 v: %2\n", p, v));
2774 if (c && _port_flags[p] & PORT_CTRLER) {
2775 c->ac->set_value(v, Controllable::NoGroup);
2778 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2780 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2781 // guard will be false if an event was written
2782 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2783 DEBUG_TRACE(DEBUG::LV2Automate,
2784 string_compose ("Thin p: %1\n", i->first));
2785 i->second->ac->alist ()->thin (20);
2789 else if (obj->body.otype == _uri_map.urids.auto_start) {
2790 const LV2_Atom* parameter = NULL;
2791 lv2_atom_object_get(obj,
2792 _uri_map.urids.auto_parameter, ¶meter,
2795 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2796 AutomationCtrlPtr c = get_automation_control (p);
2797 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2799 c->ac->start_touch (std::max ((framepos_t)0, start - _current_latency));
2804 else if (obj->body.otype == _uri_map.urids.auto_end) {
2805 const LV2_Atom* parameter = NULL;
2806 lv2_atom_object_get(obj,
2807 _uri_map.urids.auto_parameter, ¶meter,
2810 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2811 AutomationCtrlPtr c = get_automation_control (p);
2812 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2814 c->ac->stop_touch (true, std::max ((framepos_t)0, start - _current_latency));
2821 // Intercept state dirty message
2822 if (_has_state_interface /* && (flags & PORT_DIRTYMSG)*/) {
2823 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2824 if (atom->type == _uri_map.urids.atom_Blank ||
2825 atom->type == _uri_map.urids.atom_Object) {
2826 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2827 if (obj->body.otype == _uri_map.urids.state_StateChanged) {
2828 _session.set_dirty ();
2833 // Intercept patch change messages to emit PropertyChanged signal
2834 if ((flags & PORT_PATCHMSG)) {
2835 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2836 if (atom->type == _uri_map.urids.atom_Blank ||
2837 atom->type == _uri_map.urids.atom_Object) {
2838 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2839 if (obj->body.otype == _uri_map.urids.patch_Set) {
2840 const LV2_Atom* property = NULL;
2841 const LV2_Atom* value = NULL;
2842 lv2_atom_object_get(obj,
2843 _uri_map.urids.patch_property, &property,
2844 _uri_map.urids.patch_value, &value,
2847 if (property && value &&
2848 property->type == _uri_map.urids.atom_URID &&
2849 value->type == _uri_map.urids.atom_Path) {
2850 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2851 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2853 // Emit PropertyChanged signal for UI
2854 // TODO: This should emit the control's Changed signal
2855 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2857 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2863 if (!_to_ui) continue;
2864 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2865 size + sizeof(LV2_Atom),
2866 data - sizeof(LV2_Atom));
2871 cycles_t now = get_cycles();
2872 set_cycles((uint32_t)(now - then));
2874 // Update expected transport information for next cycle so we can detect changes
2875 _next_cycle_speed = speed;
2876 _next_cycle_start = end;
2879 /* keep track of lv2:timePosition like plugins can do.
2880 * Note: for no-midi plugins, we only ever send information at cycle-start,
2881 * so it needs to be realative to that.
2883 TempoMetric t = tmap.metric_at(start);
2884 _current_bpm = tmap.tempo_at_frame (start).beats_per_minute();
2885 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2886 double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
2888 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2889 beatpos *= tmetric.meter().note_divisor() / 4.0;
2890 _next_cycle_beat = beatpos + nframes * speed * _current_bpm / (60.f * _session.frame_rate());
2893 if (_latency_control_port) {
2894 framecnt_t new_latency = signal_latency ();
2895 _current_latency = new_latency;
2901 LV2Plugin::parameter_is_control(uint32_t param) const
2903 assert(param < _port_flags.size());
2904 return _port_flags[param] & PORT_CONTROL;
2908 LV2Plugin::parameter_is_audio(uint32_t param) const
2910 assert(param < _port_flags.size());
2911 return _port_flags[param] & PORT_AUDIO;
2915 LV2Plugin::parameter_is_event(uint32_t param) const
2917 assert(param < _port_flags.size());
2918 return _port_flags[param] & PORT_EVENT;
2922 LV2Plugin::parameter_is_output(uint32_t param) const
2924 assert(param < _port_flags.size());
2925 return _port_flags[param] & PORT_OUTPUT;
2929 LV2Plugin::parameter_is_input(uint32_t param) const
2931 assert(param < _port_flags.size());
2932 return _port_flags[param] & PORT_INPUT;
2936 LV2Plugin::designated_bypass_port ()
2938 const LilvPort* port = NULL;
2939 LilvNode* designation = lilv_new_uri (_world.world, LV2_CORE_PREFIX "enabled");
2940 port = lilv_plugin_get_port_by_designation (
2941 _impl->plugin, _world.lv2_InputPort, designation);
2942 lilv_node_free(designation);
2944 return lilv_port_get_index (_impl->plugin, port);
2947 /* deprecated on 2016-Sep-18 in favor of lv2:enabled */
2948 designation = lilv_new_uri (_world.world, LV2_PROCESSING_URI__enable);
2949 port = lilv_plugin_get_port_by_designation (
2950 _impl->plugin, _world.lv2_InputPort, designation);
2951 lilv_node_free(designation);
2953 return lilv_port_get_index (_impl->plugin, port);
2960 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2963 if (param < parameter_count()) {
2964 snprintf(buf, len, "%.3f", get_parameter(param));
2971 boost::shared_ptr<ScalePoints>
2972 LV2Plugin::get_scale_points(uint32_t port_index) const
2974 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2975 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2977 boost::shared_ptr<ScalePoints> ret;
2982 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2984 LILV_FOREACH(scale_points, i, points) {
2985 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2986 const LilvNode* label = lilv_scale_point_get_label(p);
2987 const LilvNode* value = lilv_scale_point_get_value(p);
2988 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2989 ret->insert(make_pair(lilv_node_as_string(label),
2990 lilv_node_as_float(value)));
2994 lilv_scale_points_free(points);
2999 LV2Plugin::run(pframes_t nframes, bool sync_work)
3001 uint32_t const N = parameter_count();
3002 for (uint32_t i = 0; i < N; ++i) {
3003 if (parameter_is_control(i) && parameter_is_input(i)) {
3004 _control_data[i] = _shadow_data[i];
3009 // Execute work synchronously if we're freewheeling (export)
3010 _worker->set_synchronous(sync_work || session().engine().freewheeling());
3013 // Run the plugin for this cycle
3014 lilv_instance_run(_impl->instance, nframes);
3016 // Emit any queued worker responses (calls a plugin callback)
3017 if (_state_worker) {
3018 _state_worker->emit_responses();
3021 _worker->emit_responses();
3024 // Notify the plugin that a work run cycle is complete
3025 if (_impl->work_iface) {
3026 if (_impl->work_iface->end_run) {
3027 _impl->work_iface->end_run(_impl->instance->lv2_handle);
3033 LV2Plugin::latency_compute_run()
3035 if (!_latency_control_port) {
3039 // Run the plugin so that it can set its latency parameter
3041 bool was_activated = _was_activated;
3044 uint32_t port_index = 0;
3045 uint32_t in_index = 0;
3046 uint32_t out_index = 0;
3048 // this is done in the main thread. non realtime.
3049 const framecnt_t bufsize = _engine.samples_per_cycle();
3050 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
3052 memset(buffer, 0, sizeof(float) * bufsize);
3054 // FIXME: Ensure plugins can handle in-place processing
3058 while (port_index < parameter_count()) {
3059 if (parameter_is_audio(port_index)) {
3060 if (parameter_is_input(port_index)) {
3061 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3063 } else if (parameter_is_output(port_index)) {
3064 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3073 if (was_activated) {
3080 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
3082 const LilvPort* port = NULL;
3083 LilvNode* designation = lilv_new_uri(_world.world, uri);
3084 port = lilv_plugin_get_port_by_designation(
3085 plugin, _world.lv2_InputPort, designation);
3086 lilv_node_free(designation);
3088 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
3093 static bool lv2_filter (const string& str, void* /*arg*/)
3095 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
3097 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
3101 LV2World::LV2World()
3102 : world(lilv_world_new())
3103 , _bundle_checked(false)
3105 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
3106 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
3107 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
3108 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
3109 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
3110 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
3111 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
3112 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
3113 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
3114 ext_expensive = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
3115 ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
3116 ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
3117 ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
3118 groups_group = lilv_new_uri(world, LV2_PORT_GROUPS__group);
3119 groups_element = lilv_new_uri(world, LV2_PORT_GROUPS__element);
3120 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
3121 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
3122 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
3123 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
3124 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
3125 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
3126 lv2_index = lilv_new_uri(world, LV2_CORE__index);
3127 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
3128 lv2_default = lilv_new_uri(world, LV2_CORE__default);
3129 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
3130 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
3131 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
3132 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
3133 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
3134 lv2_designation = lilv_new_uri(world, LV2_CORE__designation);
3135 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
3136 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
3137 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
3138 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
3139 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
3140 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
3141 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
3142 time_Position = lilv_new_uri(world, LV2_TIME__Position);
3143 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
3144 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
3145 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
3146 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
3147 units_render = lilv_new_uri(world, LV2_UNITS__render);
3148 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
3149 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
3150 units_db = lilv_new_uri(world, LV2_UNITS__db);
3151 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
3152 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
3154 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls"); // deprecated 2016-09-18
3155 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
3156 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
3157 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
3158 auto_automation_controller = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
3160 #ifdef HAVE_LV2_1_2_0
3161 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
3162 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
3163 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
3164 bufz_coarseBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#coarseBlockLength");
3169 LV2World::~LV2World()
3174 #ifdef HAVE_LV2_1_2_0
3175 lilv_node_free(bufz_coarseBlockLength);
3176 lilv_node_free(bufz_nominalBlockLength);
3177 lilv_node_free(bufz_fixedBlockLength);
3178 lilv_node_free(bufz_powerOf2BlockLength);
3181 lilv_node_free(lv2_noSampleAccurateCtrl);
3182 lilv_node_free(auto_can_write_automatation);
3183 lilv_node_free(auto_automation_control);
3184 lilv_node_free(auto_automation_controlled);
3185 lilv_node_free(auto_automation_controller);
3187 lilv_node_free(patch_Message);
3188 lilv_node_free(patch_writable);
3189 lilv_node_free(units_hz);
3190 lilv_node_free(units_midiNote);
3191 lilv_node_free(units_db);
3192 lilv_node_free(units_unit);
3193 lilv_node_free(units_render);
3194 lilv_node_free(ui_externalkx);
3195 lilv_node_free(ui_external);
3196 lilv_node_free(ui_GtkUI);
3197 lilv_node_free(time_Position);
3198 lilv_node_free(rsz_minimumSize);
3199 lilv_node_free(rdfs_comment);
3200 lilv_node_free(rdfs_label);
3201 lilv_node_free(rdfs_range);
3202 lilv_node_free(midi_MidiEvent);
3203 lilv_node_free(lv2_designation);
3204 lilv_node_free(lv2_enumeration);
3205 lilv_node_free(lv2_freewheeling);
3206 lilv_node_free(lv2_toggled);
3207 lilv_node_free(lv2_sampleRate);
3208 lilv_node_free(lv2_reportsLatency);
3209 lilv_node_free(lv2_index);
3210 lilv_node_free(lv2_integer);
3211 lilv_node_free(lv2_isSideChain);
3212 lilv_node_free(lv2_inPlaceBroken);
3213 lilv_node_free(lv2_OutputPort);
3214 lilv_node_free(lv2_InputPort);
3215 lilv_node_free(lv2_ControlPort);
3216 lilv_node_free(lv2_AudioPort);
3217 lilv_node_free(groups_group);
3218 lilv_node_free(groups_element);
3219 lilv_node_free(ext_rangeSteps);
3220 lilv_node_free(ext_notAutomatic);
3221 lilv_node_free(ext_causesArtifacts);
3222 lilv_node_free(ext_expensive);
3223 lilv_node_free(ext_notOnGUI);
3224 lilv_node_free(ext_logarithmic);
3225 lilv_node_free(ev_EventPort);
3226 lilv_node_free(atom_supports);
3227 lilv_node_free(atom_eventTransfer);
3228 lilv_node_free(atom_bufferType);
3229 lilv_node_free(atom_Sequence);
3230 lilv_node_free(atom_Chunk);
3231 lilv_node_free(atom_AtomPort);
3232 lilv_world_free(world);
3237 LV2World::load_bundled_plugins(bool verbose)
3239 if (!_bundle_checked) {
3241 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
3244 vector<string> plugin_objects;
3245 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
3246 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
3247 #ifdef PLATFORM_WINDOWS
3248 string uri = "file:///" + *x + "/";
3250 string uri = "file://" + *x + "/";
3252 LilvNode *node = lilv_new_uri(world, uri.c_str());
3253 lilv_world_load_bundle(world, node);
3254 lilv_node_free(node);
3257 lilv_world_load_all(world);
3258 _bundle_checked = true;
3262 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
3265 _plugin_uri = strdup(plugin_uri);
3268 LV2PluginInfo::~LV2PluginInfo()
3275 LV2PluginInfo::load(Session& session)
3279 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3280 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3281 if (!uri) { throw failed_constructor(); }
3282 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3283 if (!lp) { throw failed_constructor(); }
3284 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
3285 lilv_node_free(uri);
3286 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3288 } catch (failed_constructor& err) {
3289 return PluginPtr((Plugin*)0);
3295 std::vector<Plugin::PresetRecord>
3296 LV2PluginInfo::get_presets (bool /*user_only*/) const
3298 std::vector<Plugin::PresetRecord> p;
3299 #ifndef NO_PLUGIN_STATE
3300 const LilvPlugin* lp = NULL;
3303 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3304 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3305 if (!uri) { throw failed_constructor(); }
3306 lp = lilv_plugins_get_by_uri(plugins, uri);
3307 if (!lp) { throw failed_constructor(); }
3308 lilv_node_free(uri);
3309 } catch (failed_constructor& err) {
3313 // see LV2Plugin::find_presets
3314 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3315 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3316 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3318 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3319 LILV_FOREACH(nodes, i, presets) {
3320 const LilvNode* preset = lilv_nodes_get(presets, i);
3321 lilv_world_load_resource(_world.world, preset);
3322 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3323 bool userpreset = true; // TODO
3325 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
3326 lilv_node_free(name);
3329 lilv_nodes_free(presets);
3330 lilv_node_free(rdfs_label);
3331 lilv_node_free(pset_Preset);
3332 lilv_node_free(lv2_appliesTo);
3338 LV2PluginInfo::in_category (const std::string &c) const
3340 // TODO use untranslated lilv_plugin_get_class()
3341 // match gtk2_ardour/plugin_selector.cc
3342 if (category == c) {
3349 LV2PluginInfo::is_instrument () const
3351 if (category == "Instrument") {
3355 /* until we make sure that category remains untranslated in the lv2.ttl spec
3356 * and until most instruments also classify themselves as such, there's a 2nd check:
3358 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
3366 LV2PluginInfo::discover()
3369 world.load_bundled_plugins();
3370 _world.load_bundled_plugins(true);
3372 PluginInfoList* plugs = new PluginInfoList;
3373 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3375 LILV_FOREACH(plugins, i, plugins) {
3376 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3377 const LilvNode* pun = lilv_plugin_get_uri(p);
3379 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3381 LilvNode* name = lilv_plugin_get_name(p);
3382 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3383 warning << "Ignoring invalid LV2 plugin "
3384 << lilv_node_as_string(lilv_plugin_get_uri(p))
3389 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3390 warning << string_compose(
3391 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3392 lilv_node_as_string(name)) << endmsg;
3393 lilv_node_free(name);
3397 #ifdef HAVE_LV2_1_2_0
3398 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3399 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3400 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3402 warning << string_compose(
3403 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3404 lilv_node_as_string(name)) << endmsg;
3405 lilv_nodes_free(required_features);
3406 lilv_node_free(name);
3409 lilv_nodes_free(required_features);
3414 info->name = string(lilv_node_as_string(name));
3415 lilv_node_free(name);
3416 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3418 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3419 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3420 info->category = lilv_node_as_string(label);
3422 LilvNode* author_name = lilv_plugin_get_author_name(p);
3423 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3424 lilv_node_free(author_name);
3426 info->path = "/NOPATH"; // Meaningless for LV2
3428 /* count atom-event-ports that feature
3429 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3431 * TODO: nicely ask drobilla to make a lilv_ call for that
3433 int count_midi_out = 0;
3434 int count_midi_in = 0;
3435 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3436 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3437 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3438 LilvNodes* buffer_types = lilv_port_get_value(
3439 p, port, world.atom_bufferType);
3440 LilvNodes* atom_supports = lilv_port_get_value(
3441 p, port, world.atom_supports);
3443 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3444 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3445 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3448 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3452 lilv_nodes_free(buffer_types);
3453 lilv_nodes_free(atom_supports);
3457 info->n_inputs.set_audio(
3458 lilv_plugin_get_num_ports_of_class(
3459 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3460 info->n_inputs.set_midi(
3461 lilv_plugin_get_num_ports_of_class(
3462 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3465 info->n_outputs.set_audio(
3466 lilv_plugin_get_num_ports_of_class(
3467 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3468 info->n_outputs.set_midi(
3469 lilv_plugin_get_num_ports_of_class(
3470 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3473 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3474 info->index = 0; // Meaningless for LV2
3476 plugs->push_back(info);