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 // and keep track of it (for templates & archive)
1322 unsigned int saved_state = _state_version;;
1323 g_mkdir_with_parents(new_dir.c_str(), 0744);
1325 LilvState* state = lilv_state_new_from_instance(
1328 _uri_map.urid_map(),
1329 scratch_dir().c_str(),
1331 _session.externals_dir().c_str(),
1334 const_cast<LV2Plugin*>(this),
1338 if (!_plugin_state_dir.empty() || force_state_save
1340 || !lilv_state_equals(state, _impl->state)) {
1341 lilv_state_save(_world.world,
1342 _uri_map.urid_map(),
1343 _uri_map.urid_unmap(),
1349 if (force_state_save) {
1350 // archive or save-as
1351 lilv_state_free(state);
1354 else if (_plugin_state_dir.empty()) {
1355 // normal session save
1356 lilv_state_free(_impl->state);
1357 _impl->state = state;
1359 // template save (dedicated state-dir)
1360 lilv_state_free(state);
1364 // State is identical, decrement version and nuke directory
1365 lilv_state_free(state);
1366 PBD::remove_directory(new_dir);
1368 saved_state = _state_version;
1371 root->add_property("state-dir", string_compose("state%1", saved_state));
1375 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1377 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1379 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1381 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1382 lilv_nodes_free(vs);
1389 LV2Plugin::find_presets()
1391 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1392 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1393 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1395 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1396 LILV_FOREACH(nodes, i, presets) {
1397 const LilvNode* preset = lilv_nodes_get(presets, i);
1398 lilv_world_load_resource(_world.world, preset);
1399 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1400 bool userpreset = true; // TODO
1402 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1403 Plugin::PresetRecord(
1404 lilv_node_as_string(preset),
1405 lilv_node_as_string(name),
1407 lilv_node_free(name);
1409 warning << string_compose(
1410 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1411 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1412 lilv_node_as_string(preset)) << endmsg;
1415 lilv_nodes_free(presets);
1417 lilv_node_free(rdfs_label);
1418 lilv_node_free(pset_Preset);
1419 lilv_node_free(lv2_appliesTo);
1423 set_port_value(const char* port_symbol,
1429 LV2Plugin* self = (LV2Plugin*)user_data;
1430 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1431 return; // TODO: Support non-float ports
1434 const uint32_t port_index = self->port_index(port_symbol);
1435 if (port_index != (uint32_t)-1) {
1436 self->set_parameter(port_index, *(const float*)value);
1441 LV2Plugin::load_preset(PresetRecord r)
1443 LilvWorld* world = _world.world;
1444 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1445 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1447 const LV2_Feature* state_features[2] = { NULL, NULL };
1448 LV2_Worker_Schedule schedule = { _state_worker, work_schedule };
1449 const LV2_Feature state_sched_feature = { LV2_WORKER__schedule, &schedule };
1450 if (_state_worker) {
1451 state_features[0] = &state_sched_feature;
1455 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, state_features);
1456 lilv_state_free(state);
1457 Plugin::load_preset(r);
1460 lilv_node_free(pset);
1465 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1470 LV2Plugin *plugin = (LV2Plugin *) user_data;
1472 uint32_t index = plugin->port_index(port_symbol);
1473 if (index != (uint32_t) -1) {
1474 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1476 *size = sizeof(float);
1477 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1478 value = &plugin->_shadow_data[index];
1490 LV2Plugin::do_save_preset(string name)
1492 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1493 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1494 const string base_name = legalize_for_uri(name);
1495 const string file_name = base_name + ".ttl";
1496 const string bundle = Glib::build_filename(
1497 Glib::get_home_dir(),
1498 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1500 #ifdef HAVE_LILV_0_21_3
1501 /* delete reference to old preset (if any) */
1502 const PresetRecord* r = preset_by_label(name);
1504 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1506 lilv_world_unload_resource (_world.world, pset);
1507 lilv_node_free(pset);
1512 LilvState* state = lilv_state_new_from_instance(
1515 _uri_map.urid_map(),
1516 scratch_dir().c_str(), // file_dir
1517 bundle.c_str(), // copy_dir
1518 bundle.c_str(), // link_dir
1519 bundle.c_str(), // save_dir
1520 lv2plugin_get_port_value, // get_value
1521 (void*)this, // user_data
1522 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1523 _features // features
1526 lilv_state_set_label(state, name.c_str());
1528 _world.world, // world
1529 _uri_map.urid_map(), // map
1530 _uri_map.urid_unmap(), // unmap
1532 NULL, // uri (NULL = use file URI)
1533 bundle.c_str(), // dir
1534 file_name.c_str() // filename
1537 lilv_state_free(state);
1539 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1540 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1541 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1542 #ifdef HAVE_LILV_0_21_3
1543 lilv_world_unload_resource(_world.world, node_preset);
1544 lilv_world_unload_bundle(_world.world, node_bundle);
1546 lilv_world_load_bundle(_world.world, node_bundle);
1547 lilv_world_load_resource(_world.world, node_preset);
1548 lilv_node_free(node_bundle);
1549 lilv_node_free(node_preset);
1550 lilv_node_free(plug_name);
1555 LV2Plugin::do_remove_preset(string name)
1557 #ifdef HAVE_LILV_0_21_3
1558 /* Look up preset record by label (FIXME: ick, label as ID) */
1559 const PresetRecord* r = preset_by_label(name);
1564 /* Load a LilvState for the preset. */
1565 LilvWorld* world = _world.world;
1566 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1567 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1569 lilv_node_free(pset);
1573 /* Unload preset from world. */
1574 lilv_world_unload_resource(world, pset);
1576 /* Delete it from the file system. This will remove the preset file and the entry
1577 from the manifest. If this results in an empty manifest (i.e. the
1578 preset is the only thing in the bundle), then the bundle is removed. */
1579 lilv_state_delete(world, state);
1581 lilv_state_free(state);
1582 lilv_node_free(pset);
1584 /* Without lilv_state_delete(), we could delete the preset file, but this
1585 would leave a broken bundle/manifest around, so the preset would still
1586 be visible, but broken. Naively deleting a bundle is too dangerous, so
1587 we simply do not support preset deletion with older Lilv */
1591 LV2Plugin::has_editor() const
1593 return _impl->ui != NULL;
1597 LV2Plugin::has_message_output() const
1599 for (uint32_t i = 0; i < num_ports(); ++i) {
1600 if ((_port_flags[i] & PORT_SEQUENCE) &&
1601 (_port_flags[i] & PORT_OUTPUT)) {
1609 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1613 const uint8_t* body)
1615 const uint32_t buf_size = sizeof(UIMessage) + size;
1616 vector<uint8_t> buf(buf_size);
1618 UIMessage* msg = (UIMessage*)&buf[0];
1620 msg->protocol = protocol;
1622 memcpy(msg + 1, body, size);
1624 return (dest->write(&buf[0], buf_size) == buf_size);
1628 LV2Plugin::write_from_ui(uint32_t index,
1631 const uint8_t* body)
1634 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1635 /* buffer data communication from plugin UI to plugin instance.
1636 * this buffer needs to potentially hold
1637 * (port's minimumSize) * (audio-periods) / (UI-periods)
1640 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1641 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1642 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1644 * it is NOT safe to overflow (msg.size will be misinterpreted)
1646 uint32_t bufsiz = 32768;
1647 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1648 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1650 int fact = ceilf(_session.frame_rate () / 3000.f);
1651 rbs = max((size_t) bufsiz * std::max (8, fact), rbs);
1652 _from_ui = new RingBuffer<uint8_t>(rbs);
1655 if (!write_to(_from_ui, index, protocol, size, body)) {
1656 error << "Error writing from UI to plugin" << endmsg;
1663 LV2Plugin::write_to_ui(uint32_t index,
1666 const uint8_t* body)
1668 if (!write_to(_to_ui, index, protocol, size, body)) {
1669 error << "Error writing from plugin to UI" << endmsg;
1676 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1678 switch (value.type()) {
1679 case Variant::NOTHING:
1681 case Variant::BEATS:
1682 // No atom type for this, just forge a double
1683 lv2_atom_forge_double(forge, value.get_beats().to_double());
1686 lv2_atom_forge_bool(forge, value.get_bool());
1688 case Variant::DOUBLE:
1689 lv2_atom_forge_double(forge, value.get_double());
1691 case Variant::FLOAT:
1692 lv2_atom_forge_float(forge, value.get_float());
1695 lv2_atom_forge_int(forge, value.get_int());
1698 lv2_atom_forge_long(forge, value.get_long());
1701 lv2_atom_forge_path(
1702 forge, value.get_path().c_str(), value.get_path().size());
1704 case Variant::STRING:
1705 lv2_atom_forge_string(
1706 forge, value.get_string().c_str(), value.get_string().size());
1710 forge, value.get_uri().c_str(), value.get_uri().size());
1715 /** Get a variant type from a URI, return false iff no match found. */
1717 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1719 if (uri == LV2_ATOM__Bool) {
1720 type = Variant::BOOL;
1721 } else if (uri == LV2_ATOM__Double) {
1722 type = Variant::DOUBLE;
1723 } else if (uri == LV2_ATOM__Float) {
1724 type = Variant::FLOAT;
1725 } else if (uri == LV2_ATOM__Int) {
1726 type = Variant::INT;
1727 } else if (uri == LV2_ATOM__Long) {
1728 type = Variant::LONG;
1729 } else if (uri == LV2_ATOM__Path) {
1730 type = Variant::PATH;
1731 } else if (uri == LV2_ATOM__String) {
1732 type = Variant::STRING;
1733 } else if (uri == LV2_ATOM__URI) {
1734 type = Variant::URI;
1742 LV2Plugin::set_property(uint32_t key, const Variant& value)
1744 if (_patch_port_in_index == (uint32_t)-1) {
1745 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1747 } else if (value.type() == Variant::NOTHING) {
1748 error << "LV2: set_property called with void value" << endmsg;
1752 // Set up forge to write to temporary buffer on the stack
1753 LV2_Atom_Forge* forge = &_impl->ui_forge;
1754 LV2_Atom_Forge_Frame frame;
1755 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1757 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1759 // Serialize patch:Set message to set property
1760 #ifdef HAVE_LV2_1_10_0
1761 lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Set);
1762 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1763 lv2_atom_forge_urid(forge, key);
1764 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1766 lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Set);
1767 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1768 lv2_atom_forge_urid(forge, key);
1769 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1772 forge_variant(forge, value);
1774 // Write message to UI=>Plugin ring
1775 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1776 write_from_ui(_patch_port_in_index,
1777 _uri_map.urids.atom_eventTransfer,
1778 lv2_atom_total_size(atom),
1779 (const uint8_t*)atom);
1782 const ParameterDescriptor&
1783 LV2Plugin::get_property_descriptor(uint32_t id) const
1785 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1786 if (p != _property_descriptors.end()) {
1789 return Plugin::get_property_descriptor(id);
1793 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1795 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1796 desc.unit = ParameterDescriptor::MIDI_NOTE;
1797 } else if (lilv_nodes_contains(units, _world.units_db)) {
1798 desc.unit = ParameterDescriptor::DB;
1799 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1800 desc.unit = ParameterDescriptor::HZ;
1802 if (lilv_nodes_size(units) > 0) {
1803 const LilvNode* unit = lilv_nodes_get_first(units);
1804 LilvNode* render = get_value(lworld, unit, _world.units_render);
1806 desc.print_fmt = lilv_node_as_string(render);
1807 replace_all (desc.print_fmt, "%f", "%.2f");
1808 lilv_node_free(render);
1814 load_parameter_descriptor(LV2World& world,
1815 ParameterDescriptor& desc,
1816 Variant::Type datatype,
1817 const LilvNode* subject)
1819 LilvWorld* lworld = _world.world;
1820 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1821 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1822 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1823 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1824 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1826 desc.label = lilv_node_as_string(label);
1829 if (lilv_node_is_float(def)) {
1830 desc.normal = lilv_node_as_float(def);
1831 } else if (lilv_node_is_int(def)) {
1832 desc.normal = lilv_node_as_int(def);
1836 if (lilv_node_is_float(minimum)) {
1837 desc.lower = lilv_node_as_float(minimum);
1838 } else if (lilv_node_is_int(minimum)) {
1839 desc.lower = lilv_node_as_int(minimum);
1843 if (lilv_node_is_float(maximum)) {
1844 desc.upper = lilv_node_as_float(maximum);
1845 } else if (lilv_node_is_int(maximum)) {
1846 desc.upper = lilv_node_as_int(maximum);
1849 load_parameter_descriptor_units(lworld, desc, units);
1850 desc.datatype = datatype;
1851 desc.toggled |= datatype == Variant::BOOL;
1852 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1853 desc.update_steps();
1855 lilv_nodes_free(units);
1856 lilv_node_free(label);
1857 lilv_node_free(def);
1858 lilv_node_free(minimum);
1859 lilv_node_free(maximum);
1863 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1865 LilvWorld* lworld = _world.world;
1866 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1867 LilvNodes* properties = lilv_world_find_nodes(
1868 lworld, subject, _world.patch_writable, NULL);
1869 LILV_FOREACH(nodes, p, properties) {
1870 // Get label and range
1871 const LilvNode* prop = lilv_nodes_get(properties, p);
1872 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1874 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1875 lilv_node_as_uri(prop)) << endmsg;
1879 // Convert range to variant type (TODO: support for multiple range types)
1880 Variant::Type datatype;
1881 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1882 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1883 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1887 // Add description to result
1888 ParameterDescriptor desc;
1889 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1890 desc.datatype = datatype;
1891 load_parameter_descriptor(_world, desc, datatype, prop);
1892 descs.insert(std::make_pair(desc.key, desc));
1894 lilv_node_free(range);
1896 lilv_nodes_free(properties);
1900 LV2Plugin::announce_property_values()
1902 if (_patch_port_in_index == (uint32_t)-1) {
1906 // Set up forge to write to temporary buffer on the stack
1907 LV2_Atom_Forge* forge = &_impl->ui_forge;
1908 LV2_Atom_Forge_Frame frame;
1909 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1911 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1913 // Serialize patch:Get message with no subject (implicitly plugin instance)
1914 #ifdef HAVE_LV2_1_10_0
1915 lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Get);
1917 lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Get);
1920 // Write message to UI=>Plugin ring
1921 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1922 write_from_ui(_patch_port_in_index,
1923 _uri_map.urids.atom_eventTransfer,
1924 lv2_atom_total_size(atom),
1925 (const uint8_t*)atom);
1929 LV2Plugin::enable_ui_emission()
1932 /* see note in LV2Plugin::write_from_ui() */
1933 uint32_t bufsiz = 32768;
1934 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1935 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1937 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1938 rbs = max((size_t) bufsiz * 8, rbs);
1939 _to_ui = new RingBuffer<uint8_t>(rbs);
1944 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1950 uint32_t read_space = _to_ui->read_space();
1951 while (read_space > sizeof(UIMessage)) {
1953 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1954 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1957 vector<uint8_t> body(msg.size);
1958 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1959 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1963 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1965 read_space -= sizeof(msg) + msg.size;
1970 LV2Plugin::work(Worker& worker, uint32_t size, const void* data)
1972 Glib::Threads::Mutex::Lock lm(_work_mutex);
1973 return _impl->work_iface->work(
1974 _impl->instance->lv2_handle, work_respond, &worker, size, data);
1978 LV2Plugin::work_response(uint32_t size, const void* data)
1980 return _impl->work_iface->work_response(
1981 _impl->instance->lv2_handle, size, data);
1985 LV2Plugin::set_insert_id(PBD::ID id)
1987 if (_insert_id == "0") {
1989 } else if (_insert_id != id) {
1990 lilv_state_free(_impl->state);
1991 _impl->state = NULL;
1997 LV2Plugin::set_state_dir (const std::string& d)
1999 _plugin_state_dir = d;
2003 LV2Plugin::set_state(const XMLNode& node, int version)
2006 XMLProperty const * prop;
2007 XMLNodeConstIterator iter;
2014 if (node.name() != state_node_name()) {
2015 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
2019 #ifndef NO_PLUGIN_STATE
2021 if (version < 3000) {
2022 nodes = node.children("port");
2024 nodes = node.children("Port");
2027 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
2031 if ((prop = child->property("symbol")) != 0) {
2032 sym = prop->value().c_str();
2034 warning << _("LV2: port has no symbol, ignored") << endmsg;
2038 map<string, uint32_t>::iterator i = _port_indices.find(sym);
2040 if (i != _port_indices.end()) {
2041 port_id = i->second;
2043 warning << _("LV2: port has unknown index, ignored") << endmsg;
2047 if ((prop = child->property("value")) != 0) {
2048 value = prop->value().c_str();
2050 warning << _("LV2: port has no value, ignored") << endmsg;
2054 set_parameter(port_id, atof(value));
2057 if ((prop = node.property("template-dir")) != 0) {
2058 set_state_dir (prop->value ());
2062 if ((prop = node.property("state-dir")) != 0) {
2063 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
2064 error << string_compose(
2065 "LV2: failed to parse state version from \"%1\"",
2066 prop->value()) << endmsg;
2069 std::string state_file = Glib::build_filename(
2071 Glib::build_filename(prop->value(), "state.ttl"));
2073 LilvState* state = lilv_state_new_from_file(
2074 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
2076 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
2077 lilv_state_free(_impl->state);
2078 _impl->state = state;
2081 if (!_plugin_state_dir.empty ()) {
2082 // force save with session, next time (increment counter)
2083 lilv_state_free (_impl->state);
2084 _impl->state = NULL;
2088 latency_compute_run();
2091 return Plugin::set_state(node, version);
2095 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
2097 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
2099 error << string_compose("LV2: get descriptor of non-existent port %1", which)
2104 LilvNodes* portunits;
2105 LilvNode *def, *min, *max;
2106 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
2107 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
2109 LilvNode* steps = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
2111 // TODO: Once we can rely on lilv 0.18.0 being present,
2112 // load_parameter_descriptor() can be used for ports as well
2113 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
2114 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
2115 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
2116 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
2117 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
2118 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
2119 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
2120 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
2121 load_parameter_descriptor_units(_world.world, desc, portunits);
2123 if (desc.sr_dependent) {
2124 desc.lower *= _session.frame_rate ();
2125 desc.upper *= _session.frame_rate ();
2128 desc.min_unbound = false; // TODO: LV2 extension required
2129 desc.max_unbound = false; // TODO: LV2 extension required
2131 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
2132 desc.scale_points = get_scale_points(which);
2134 desc.update_steps();
2137 //override auto-calculated steps in update_steps()
2138 float s = lilv_node_as_float (steps);
2139 const float delta = desc.upper - desc.lower;
2141 desc.step = desc.smallstep = (delta / s);
2142 desc.largestep = std::min ((delta / 5.0f), 10.f * desc.smallstep);
2144 if (desc.logarithmic) {
2145 // TODO marry AutomationControl::internal_to_interface () with
2146 // http://lv2plug.in/ns/ext/port-props/#rangeSteps
2147 desc.smallstep = desc.smallstep / logf(s);
2148 desc.step = desc.step / logf(s);
2149 desc.largestep = desc.largestep / logf(s);
2150 } else if (desc.integer_step) {
2151 desc.smallstep = 1.0;
2152 desc.step = std::max(1.f, rintf (desc.step));
2153 desc.largestep = std::max(1.f, rintf (desc.largestep));
2155 DEBUG_TRACE(DEBUG::LV2, string_compose("parameter %1 small: %2, step: %3 largestep: %4\n",
2156 which, desc.smallstep, desc.step, desc.largestep));
2160 lilv_node_free(def);
2161 lilv_node_free(min);
2162 lilv_node_free(max);
2163 lilv_node_free(steps);
2164 lilv_nodes_free(portunits);
2169 Plugin::IOPortDescription
2170 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2172 PortFlags match = 0;
2174 case DataType::AUDIO:
2177 case DataType::MIDI:
2178 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2181 return Plugin::IOPortDescription ("?");
2185 match |= PORT_INPUT;
2187 match |= PORT_OUTPUT;
2191 uint32_t idx = UINT32_MAX;
2193 uint32_t const num_ports = parameter_count();
2194 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2195 PortFlags flags = _port_flags[port_index];
2196 if ((flags & match) == match) {
2203 if (idx == UINT32_MAX) {
2204 return Plugin::IOPortDescription ("?");
2207 const LilvPort* pport = lilv_plugin_get_port_by_index (_impl->plugin, idx);
2209 LilvNode* name = lilv_port_get_name(_impl->plugin, pport);
2210 Plugin::IOPortDescription iod (lilv_node_as_string (name));
2211 lilv_node_free(name);
2213 /* get the port's pg:group */
2214 LilvNodes* groups = lilv_port_get_value (_impl->plugin, pport, _world.groups_group);
2215 if (lilv_nodes_size (groups) > 0) {
2216 const LilvNode* group = lilv_nodes_get_first (groups);
2217 LilvNodes* grouplabel = lilv_world_find_nodes (_world.world, group, _world.rdfs_label, NULL);
2219 /* get the name of the port-group */
2220 if (lilv_nodes_size (grouplabel) > 0) {
2221 const LilvNode* grpname = lilv_nodes_get_first (grouplabel);
2222 iod.group_name = lilv_node_as_string (grpname);
2224 lilv_nodes_free (grouplabel);
2226 /* get all port designations.
2227 * we're interested in e.g. lv2:designation pg:right */
2228 LilvNodes* designations = lilv_port_get_value (_impl->plugin, pport, _world.lv2_designation);
2229 if (lilv_nodes_size (designations) > 0) {
2230 /* get all pg:elements of the pg:group */
2231 LilvNodes* group_childs = lilv_world_find_nodes (_world.world, group, _world.groups_element, NULL);
2232 if (lilv_nodes_size (group_childs) > 0) {
2233 /* iterate over all port designations .. */
2234 LILV_FOREACH (nodes, i, designations) {
2235 const LilvNode* designation = lilv_nodes_get (designations, i);
2236 /* match the lv2:designation's element against the port-group's element */
2237 LILV_FOREACH (nodes, j, group_childs) {
2238 const LilvNode* group_element = lilv_nodes_get (group_childs, j);
2239 LilvNodes* elem = lilv_world_find_nodes (_world.world, group_element, _world.lv2_designation, designation);
2240 /* found it. Now look up the index (channel-number) of the pg:Element */
2241 if (lilv_nodes_size (elem) > 0) {
2242 LilvNodes* idx = lilv_world_find_nodes (_world.world, lilv_nodes_get_first (elem), _world.lv2_index, NULL);
2243 if (lilv_node_is_int (lilv_nodes_get_first (idx))) {
2244 iod.group_channel = lilv_node_as_int(lilv_nodes_get_first (idx));
2251 lilv_nodes_free (groups);
2252 lilv_nodes_free (designations);
2255 if (lilv_port_has_property(_impl->plugin, pport, _world.lv2_isSideChain)) {
2256 iod.is_sidechain = true;
2262 LV2Plugin::describe_parameter(Evoral::Parameter which)
2264 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2266 if (lilv_port_has_property(_impl->plugin,
2267 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2268 return X_("hidden");
2271 if (lilv_port_has_property(_impl->plugin,
2272 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2273 return X_("hidden");
2276 if (lilv_port_has_property(_impl->plugin,
2277 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2278 return X_("latency");
2281 LilvNode* name = lilv_port_get_name(_impl->plugin,
2282 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2283 string ret(lilv_node_as_string(name));
2284 lilv_node_free(name);
2292 LV2Plugin::max_latency () const
2294 return _max_latency;
2298 LV2Plugin::signal_latency() const
2300 if (_latency_control_port) {
2301 return (framecnt_t)floor(*_latency_control_port);
2307 set<Evoral::Parameter>
2308 LV2Plugin::automatable() const
2310 set<Evoral::Parameter> ret;
2312 for (uint32_t i = 0; i < parameter_count(); ++i) {
2313 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2314 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2318 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2319 p != _property_descriptors.end();
2321 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2327 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2329 if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2330 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2331 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2335 LV2Plugin::AutomationCtrlPtr
2336 LV2Plugin::get_automation_control (uint32_t i)
2338 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2339 return AutomationCtrlPtr ();
2341 return _ctrl_map[i];
2345 LV2Plugin::activate()
2347 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2349 if (!_was_activated) {
2350 lilv_instance_activate(_impl->instance);
2351 _was_activated = true;
2356 LV2Plugin::deactivate()
2358 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2360 if (_was_activated) {
2361 lilv_instance_deactivate(_impl->instance);
2362 _was_activated = false;
2367 LV2Plugin::cleanup()
2369 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2372 lilv_instance_free(_impl->instance);
2373 _impl->instance = NULL;
2377 LV2Plugin::allocate_atom_event_buffers()
2379 /* reserve local scratch buffers for ATOM event-queues */
2380 const LilvPlugin* p = _impl->plugin;
2382 /* count non-MIDI atom event-ports
2383 * TODO: nicely ask drobilla to make a lilv_ call for that
2385 int count_atom_out = 0;
2386 int count_atom_in = 0;
2387 int minimumSize = 32768; // TODO use a per-port minimum-size
2388 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2389 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2390 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2391 LilvNodes* buffer_types = lilv_port_get_value(
2392 p, port, _world.atom_bufferType);
2393 LilvNodes* atom_supports = lilv_port_get_value(
2394 p, port, _world.atom_supports);
2396 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2397 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2400 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2403 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2404 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2405 if (min_size && lilv_node_is_int(min_size)) {
2406 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2408 lilv_nodes_free(min_size_v);
2410 lilv_nodes_free(buffer_types);
2411 lilv_nodes_free(atom_supports);
2415 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2416 name(), count_atom_in, count_atom_out));
2418 const int total_atom_buffers = (count_atom_in + count_atom_out);
2419 if (_atom_ev_buffers || total_atom_buffers == 0) {
2423 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2424 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2425 for (int i = 0; i < total_atom_buffers; ++i ) {
2426 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2427 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2429 _atom_ev_buffers[total_atom_buffers] = 0;
2433 /** Write an ardour position/time/tempo/meter as an LV2 event.
2434 * @return true on success.
2437 write_position(LV2_Atom_Forge* forge,
2439 const TempoMetric& t,
2440 Timecode::BBT_Time& bbt,
2443 framepos_t position,
2446 const URIMap::URIDs& urids = URIMap::instance().urids;
2448 uint8_t pos_buf[256];
2449 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2450 LV2_Atom_Forge_Frame frame;
2451 #ifdef HAVE_LV2_1_10_0
2452 lv2_atom_forge_object(forge, &frame, 0, urids.time_Position);
2453 lv2_atom_forge_key(forge, urids.time_frame);
2454 lv2_atom_forge_long(forge, position);
2455 lv2_atom_forge_key(forge, urids.time_speed);
2456 lv2_atom_forge_float(forge, speed);
2457 lv2_atom_forge_key(forge, urids.time_barBeat);
2458 lv2_atom_forge_float(forge, bbt.beats - 1 +
2459 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2460 lv2_atom_forge_key(forge, urids.time_bar);
2461 lv2_atom_forge_long(forge, bbt.bars - 1);
2462 lv2_atom_forge_key(forge, urids.time_beatUnit);
2463 lv2_atom_forge_int(forge, t.meter().note_divisor());
2464 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2465 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2466 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2467 lv2_atom_forge_float(forge, bpm);
2469 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2470 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2471 lv2_atom_forge_long(forge, position);
2472 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2473 lv2_atom_forge_float(forge, speed);
2474 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2475 lv2_atom_forge_float(forge, bbt.beats - 1 +
2476 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2477 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2478 lv2_atom_forge_long(forge, bbt.bars - 1);
2479 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2480 lv2_atom_forge_int(forge, t.meter().note_divisor());
2481 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2482 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2483 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2484 lv2_atom_forge_float(forge, bpm);
2487 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2488 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2489 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2490 (const uint8_t*)(atom + 1));
2494 LV2Plugin::connect_and_run(BufferSet& bufs,
2495 framepos_t start, framepos_t end, double speed,
2496 ChanMapping in_map, ChanMapping out_map,
2497 pframes_t nframes, framecnt_t offset)
2499 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2500 Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2502 cycles_t then = get_cycles();
2504 TempoMap& tmap = _session.tempo_map();
2505 Metrics::const_iterator metric_i = tmap.metrics_end();
2506 TempoMetric tmetric = tmap.metric_at(start, &metric_i);
2508 if (_freewheel_control_port) {
2509 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2512 if (_bpm_control_port) {
2513 *_bpm_control_port = tmap.tempo_at_frame (start).note_types_per_minute();
2517 if (_can_write_automation && start != _next_cycle_start) {
2518 // add guard-points after locating
2519 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2520 i->second->guard = true;
2525 ChanCount bufs_count;
2526 bufs_count.set(DataType::AUDIO, 1);
2527 bufs_count.set(DataType::MIDI, 1);
2528 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2529 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2530 uint32_t const num_ports = parameter_count();
2531 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2533 uint32_t audio_in_index = 0;
2534 uint32_t audio_out_index = 0;
2535 uint32_t midi_in_index = 0;
2536 uint32_t midi_out_index = 0;
2537 uint32_t atom_port_index = 0;
2538 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2540 uint32_t index = nil_index;
2541 PortFlags flags = _port_flags[port_index];
2543 if (flags & PORT_AUDIO) {
2544 if (flags & PORT_INPUT) {
2545 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2547 ? bufs.get_audio(index).data(offset)
2548 : silent_bufs.get_audio(0).data(offset);
2550 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2552 ? bufs.get_audio(index).data(offset)
2553 : scratch_bufs.get_audio(0).data(offset);
2555 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2556 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2557 be necessary, but the mapping is illegal in some cases. Ideally
2558 that should be fixed, but this is easier...
2560 if (flags & PORT_MIDI) {
2561 if (flags & PORT_INPUT) {
2562 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2564 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2566 if (valid && bufs.count().n_midi() > index) {
2567 /* Note, ensure_lv2_bufsize() is not RT safe!
2568 * However free()/alloc() is only called if a
2569 * plugin requires a rsz:minimumSize buffersize
2570 * and the existing buffer if smaller.
2572 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2573 _ev_buffers[port_index] = bufs.get_lv2_midi(
2574 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2576 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2577 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2578 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2582 if (valid && (flags & PORT_INPUT)) {
2583 if ((flags & PORT_POSITION)) {
2584 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2585 double bpm = tmap.tempo_at_frame (start).note_types_per_minute();
2586 double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
2588 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2589 beatpos *= tmetric.meter().note_divisor() / 4.0;
2590 if (start != _next_cycle_start ||
2591 speed != _next_cycle_speed ||
2592 rint (1000 * beatpos) != rint(1000 * _next_cycle_beat) ||
2593 bpm != _current_bpm) {
2594 // Transport or Tempo has changed, write position at cycle start
2595 write_position(&_impl->forge, _ev_buffers[port_index],
2596 tmetric, bbt, speed, bpm, start, 0);
2600 // Get MIDI iterator range (empty range if no MIDI)
2601 MidiBuffer::iterator m = (index != nil_index)
2602 ? bufs.get_midi(index).begin()
2603 : silent_bufs.get_midi(0).end();
2604 MidiBuffer::iterator m_end = (index != nil_index)
2605 ? bufs.get_midi(index).end()
2608 // Now merge MIDI and any transport events into the buffer
2609 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2610 const framepos_t tend = end;
2612 while (m != m_end || (metric_i != tmap.metrics_end() &&
2613 (*metric_i)->frame() < tend)) {
2614 MetricSection* metric = (metric_i != tmap.metrics_end())
2616 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2617 const Evoral::Event<framepos_t> ev(*m, false);
2618 if (ev.time() < nframes) {
2619 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2620 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2624 tmetric.set_metric(metric);
2625 Timecode::BBT_Time bbt;
2626 bbt = tmap.bbt_at_frame (metric->frame());
2627 double bpm = tmap.tempo_at_frame (start/*XXX*/).note_types_per_minute();
2628 write_position(&_impl->forge, _ev_buffers[port_index],
2629 tmetric, bbt, speed, bpm,
2631 metric->frame() - start);
2635 } else if (!valid) {
2636 // Nothing we understand or care about, connect to scratch
2637 // see note for midi-buffer size above
2638 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2639 0, _port_minimumSize[port_index]);
2640 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2641 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2644 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2646 continue; // Control port, leave buffer alone
2648 lilv_instance_connect_port(_impl->instance, port_index, buf);
2651 // Read messages from UI and push into appropriate buffers
2653 uint32_t read_space = _from_ui->read_space();
2654 while (read_space > sizeof(UIMessage)) {
2656 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2657 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2660 vector<uint8_t> body(msg.size);
2661 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2662 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2665 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2666 LV2_Evbuf* buf = _ev_buffers[msg.index];
2667 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2668 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2669 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2670 (const uint8_t*)(atom + 1))) {
2671 error << "Failed to write data to LV2 event buffer\n";
2674 error << "Received unknown message type from UI" << endmsg;
2676 read_space -= sizeof(UIMessage) + msg.size;
2683 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2684 PortFlags flags = _port_flags[port_index];
2687 /* TODO ask drobilla about comment
2688 * "Make Ardour event buffers generic so plugins can communicate"
2689 * in libs/ardour/buffer_set.cc:310
2691 * ideally the user could choose which of the following two modes
2692 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2694 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2695 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2696 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2697 * for quite a while at least ;)
2699 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2700 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2701 const uint32_t buf_index = out_map.get(
2702 DataType::MIDI, midi_out_index++, &valid);
2704 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2707 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2708 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2709 const uint32_t buf_index = out_map.get(
2710 DataType::MIDI, midi_out_index++, &valid);
2712 bufs.flush_lv2_midi(true, buf_index);
2716 // Write messages to UI
2717 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2718 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2719 LV2_Evbuf* buf = _ev_buffers[port_index];
2720 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2721 lv2_evbuf_is_valid(i);
2722 i = lv2_evbuf_next(i)) {
2723 uint32_t frames, subframes, type, size;
2725 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2728 // Intercept Automation Write Events
2729 if ((flags & PORT_AUTOCTRL)) {
2730 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2731 if (atom->type == _uri_map.urids.atom_Blank ||
2732 atom->type == _uri_map.urids.atom_Object) {
2733 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2734 if (obj->body.otype == _uri_map.urids.auto_event) {
2735 // only if transport_rolling ??
2736 const LV2_Atom* parameter = NULL;
2737 const LV2_Atom* value = NULL;
2738 lv2_atom_object_get(obj,
2739 _uri_map.urids.auto_parameter, ¶meter,
2740 _uri_map.urids.auto_value, &value,
2742 if (parameter && value) {
2743 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2744 const float v = ((const LV2_Atom_Float*)value)->body;
2745 // -> add automation event..
2746 DEBUG_TRACE(DEBUG::LV2Automate,
2747 string_compose ("Event p: %1 t: %2 v: %3\n", p, frames, v));
2748 AutomationCtrlPtr c = get_automation_control (p);
2750 (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2752 framepos_t when = std::max ((framepos_t) 0, start + frames - _current_latency);
2753 assert (start + frames - _current_latency >= 0);
2756 c->ac->list()->add (when, v, true, true);
2758 c->ac->set_double (v, when, true);
2763 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2764 // TODO optional arguments, for now we assume the plugin
2765 // writes automation for its own inputs
2766 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2767 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2768 if (_port_flags[i->first] & PORT_CTRLED) {
2769 DEBUG_TRACE(DEBUG::LV2Automate,
2770 string_compose ("Setup p: %1\n", i->first));
2771 i->second->ac->set_automation_state (Touch);
2775 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2776 // set [touched] parameters to "play" ??
2777 // allow plugin to change its mode (from analyze to apply)
2778 const LV2_Atom* parameter = NULL;
2779 const LV2_Atom* value = NULL;
2780 lv2_atom_object_get(obj,
2781 _uri_map.urids.auto_parameter, ¶meter,
2782 _uri_map.urids.auto_value, &value,
2784 if (parameter && value) {
2785 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2786 const float v = ((const LV2_Atom_Float*)value)->body;
2787 AutomationCtrlPtr c = get_automation_control (p);
2788 DEBUG_TRACE(DEBUG::LV2Automate,
2789 string_compose ("Finalize p: %1 v: %2\n", p, v));
2790 if (c && _port_flags[p] & PORT_CTRLER) {
2791 c->ac->set_value(v, Controllable::NoGroup);
2794 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2796 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2797 // guard will be false if an event was written
2798 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2799 DEBUG_TRACE(DEBUG::LV2Automate,
2800 string_compose ("Thin p: %1\n", i->first));
2801 i->second->ac->alist ()->thin (20);
2805 else if (obj->body.otype == _uri_map.urids.auto_start) {
2806 const LV2_Atom* parameter = NULL;
2807 lv2_atom_object_get(obj,
2808 _uri_map.urids.auto_parameter, ¶meter,
2811 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2812 AutomationCtrlPtr c = get_automation_control (p);
2813 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2815 c->ac->start_touch (std::max ((framepos_t)0, start - _current_latency));
2820 else if (obj->body.otype == _uri_map.urids.auto_end) {
2821 const LV2_Atom* parameter = NULL;
2822 lv2_atom_object_get(obj,
2823 _uri_map.urids.auto_parameter, ¶meter,
2826 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2827 AutomationCtrlPtr c = get_automation_control (p);
2828 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2830 c->ac->stop_touch (true, std::max ((framepos_t)0, start - _current_latency));
2837 // Intercept state dirty message
2838 if (_has_state_interface /* && (flags & PORT_DIRTYMSG)*/) {
2839 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2840 if (atom->type == _uri_map.urids.atom_Blank ||
2841 atom->type == _uri_map.urids.atom_Object) {
2842 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2843 if (obj->body.otype == _uri_map.urids.state_StateChanged) {
2844 _session.set_dirty ();
2849 // Intercept patch change messages to emit PropertyChanged signal
2850 if ((flags & PORT_PATCHMSG)) {
2851 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2852 if (atom->type == _uri_map.urids.atom_Blank ||
2853 atom->type == _uri_map.urids.atom_Object) {
2854 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2855 if (obj->body.otype == _uri_map.urids.patch_Set) {
2856 const LV2_Atom* property = NULL;
2857 const LV2_Atom* value = NULL;
2858 lv2_atom_object_get(obj,
2859 _uri_map.urids.patch_property, &property,
2860 _uri_map.urids.patch_value, &value,
2863 if (property && value &&
2864 property->type == _uri_map.urids.atom_URID &&
2865 value->type == _uri_map.urids.atom_Path) {
2866 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2867 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2869 // Emit PropertyChanged signal for UI
2870 // TODO: This should emit the control's Changed signal
2871 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2873 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2879 if (!_to_ui) continue;
2880 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2881 size + sizeof(LV2_Atom),
2882 data - sizeof(LV2_Atom));
2887 cycles_t now = get_cycles();
2888 set_cycles((uint32_t)(now - then));
2890 // Update expected transport information for next cycle so we can detect changes
2891 _next_cycle_speed = speed;
2892 _next_cycle_start = end;
2895 /* keep track of lv2:timePosition like plugins can do.
2896 * Note: for no-midi plugins, we only ever send information at cycle-start,
2897 * so it needs to be realative to that.
2899 TempoMetric t = tmap.metric_at(start);
2900 _current_bpm = tmap.tempo_at_frame (start).note_types_per_minute();
2901 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2902 double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
2904 + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2905 beatpos *= tmetric.meter().note_divisor() / 4.0;
2906 _next_cycle_beat = beatpos + nframes * speed * _current_bpm / (60.f * _session.frame_rate());
2909 if (_latency_control_port) {
2910 framecnt_t new_latency = signal_latency ();
2911 _current_latency = new_latency;
2917 LV2Plugin::parameter_is_control(uint32_t param) const
2919 assert(param < _port_flags.size());
2920 return _port_flags[param] & PORT_CONTROL;
2924 LV2Plugin::parameter_is_audio(uint32_t param) const
2926 assert(param < _port_flags.size());
2927 return _port_flags[param] & PORT_AUDIO;
2931 LV2Plugin::parameter_is_event(uint32_t param) const
2933 assert(param < _port_flags.size());
2934 return _port_flags[param] & PORT_EVENT;
2938 LV2Plugin::parameter_is_output(uint32_t param) const
2940 assert(param < _port_flags.size());
2941 return _port_flags[param] & PORT_OUTPUT;
2945 LV2Plugin::parameter_is_input(uint32_t param) const
2947 assert(param < _port_flags.size());
2948 return _port_flags[param] & PORT_INPUT;
2952 LV2Plugin::designated_bypass_port ()
2954 const LilvPort* port = NULL;
2955 LilvNode* designation = lilv_new_uri (_world.world, LV2_CORE_PREFIX "enabled");
2956 port = lilv_plugin_get_port_by_designation (
2957 _impl->plugin, _world.lv2_InputPort, designation);
2958 lilv_node_free(designation);
2960 return lilv_port_get_index (_impl->plugin, port);
2963 /* deprecated on 2016-Sep-18 in favor of lv2:enabled */
2964 designation = lilv_new_uri (_world.world, LV2_PROCESSING_URI__enable);
2965 port = lilv_plugin_get_port_by_designation (
2966 _impl->plugin, _world.lv2_InputPort, designation);
2967 lilv_node_free(designation);
2969 return lilv_port_get_index (_impl->plugin, port);
2976 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2979 if (param < parameter_count()) {
2980 snprintf(buf, len, "%.3f", get_parameter(param));
2987 boost::shared_ptr<ScalePoints>
2988 LV2Plugin::get_scale_points(uint32_t port_index) const
2990 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2991 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2993 boost::shared_ptr<ScalePoints> ret;
2998 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
3000 LILV_FOREACH(scale_points, i, points) {
3001 const LilvScalePoint* p = lilv_scale_points_get(points, i);
3002 const LilvNode* label = lilv_scale_point_get_label(p);
3003 const LilvNode* value = lilv_scale_point_get_value(p);
3004 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
3005 ret->insert(make_pair(lilv_node_as_string(label),
3006 lilv_node_as_float(value)));
3010 lilv_scale_points_free(points);
3015 LV2Plugin::run(pframes_t nframes, bool sync_work)
3017 uint32_t const N = parameter_count();
3018 for (uint32_t i = 0; i < N; ++i) {
3019 if (parameter_is_control(i) && parameter_is_input(i)) {
3020 _control_data[i] = _shadow_data[i];
3025 // Execute work synchronously if we're freewheeling (export)
3026 _worker->set_synchronous(sync_work || session().engine().freewheeling());
3029 // Run the plugin for this cycle
3030 lilv_instance_run(_impl->instance, nframes);
3032 // Emit any queued worker responses (calls a plugin callback)
3033 if (_state_worker) {
3034 _state_worker->emit_responses();
3037 _worker->emit_responses();
3040 // Notify the plugin that a work run cycle is complete
3041 if (_impl->work_iface) {
3042 if (_impl->work_iface->end_run) {
3043 _impl->work_iface->end_run(_impl->instance->lv2_handle);
3049 LV2Plugin::latency_compute_run()
3051 if (!_latency_control_port) {
3055 // Run the plugin so that it can set its latency parameter
3057 bool was_activated = _was_activated;
3060 uint32_t port_index = 0;
3061 uint32_t in_index = 0;
3062 uint32_t out_index = 0;
3064 // this is done in the main thread. non realtime.
3065 const framecnt_t bufsize = _engine.samples_per_cycle();
3066 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
3068 memset(buffer, 0, sizeof(float) * bufsize);
3070 // FIXME: Ensure plugins can handle in-place processing
3074 while (port_index < parameter_count()) {
3075 if (parameter_is_audio(port_index)) {
3076 if (parameter_is_input(port_index)) {
3077 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3079 } else if (parameter_is_output(port_index)) {
3080 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3089 if (was_activated) {
3096 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
3098 const LilvPort* port = NULL;
3099 LilvNode* designation = lilv_new_uri(_world.world, uri);
3100 port = lilv_plugin_get_port_by_designation(
3101 plugin, _world.lv2_InputPort, designation);
3102 lilv_node_free(designation);
3104 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
3109 static bool lv2_filter (const string& str, void* /*arg*/)
3111 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
3113 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
3117 LV2World::LV2World()
3118 : world(lilv_world_new())
3119 , _bundle_checked(false)
3121 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
3122 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
3123 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
3124 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
3125 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
3126 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
3127 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
3128 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
3129 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
3130 ext_expensive = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
3131 ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
3132 ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
3133 ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
3134 groups_group = lilv_new_uri(world, LV2_PORT_GROUPS__group);
3135 groups_element = lilv_new_uri(world, LV2_PORT_GROUPS__element);
3136 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
3137 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
3138 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
3139 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
3140 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
3141 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
3142 lv2_index = lilv_new_uri(world, LV2_CORE__index);
3143 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
3144 lv2_default = lilv_new_uri(world, LV2_CORE__default);
3145 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
3146 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
3147 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
3148 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
3149 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
3150 lv2_designation = lilv_new_uri(world, LV2_CORE__designation);
3151 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
3152 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
3153 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
3154 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
3155 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
3156 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
3157 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
3158 time_Position = lilv_new_uri(world, LV2_TIME__Position);
3159 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
3160 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
3161 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
3162 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
3163 units_render = lilv_new_uri(world, LV2_UNITS__render);
3164 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
3165 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
3166 units_db = lilv_new_uri(world, LV2_UNITS__db);
3167 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
3168 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
3170 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls"); // deprecated 2016-09-18
3171 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
3172 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
3173 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
3174 auto_automation_controller = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
3176 #ifdef HAVE_LV2_1_2_0
3177 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
3178 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
3179 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
3180 bufz_coarseBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#coarseBlockLength");
3185 LV2World::~LV2World()
3190 #ifdef HAVE_LV2_1_2_0
3191 lilv_node_free(bufz_coarseBlockLength);
3192 lilv_node_free(bufz_nominalBlockLength);
3193 lilv_node_free(bufz_fixedBlockLength);
3194 lilv_node_free(bufz_powerOf2BlockLength);
3197 lilv_node_free(lv2_noSampleAccurateCtrl);
3198 lilv_node_free(auto_can_write_automatation);
3199 lilv_node_free(auto_automation_control);
3200 lilv_node_free(auto_automation_controlled);
3201 lilv_node_free(auto_automation_controller);
3203 lilv_node_free(patch_Message);
3204 lilv_node_free(patch_writable);
3205 lilv_node_free(units_hz);
3206 lilv_node_free(units_midiNote);
3207 lilv_node_free(units_db);
3208 lilv_node_free(units_unit);
3209 lilv_node_free(units_render);
3210 lilv_node_free(ui_externalkx);
3211 lilv_node_free(ui_external);
3212 lilv_node_free(ui_GtkUI);
3213 lilv_node_free(time_Position);
3214 lilv_node_free(rsz_minimumSize);
3215 lilv_node_free(rdfs_comment);
3216 lilv_node_free(rdfs_label);
3217 lilv_node_free(rdfs_range);
3218 lilv_node_free(midi_MidiEvent);
3219 lilv_node_free(lv2_designation);
3220 lilv_node_free(lv2_enumeration);
3221 lilv_node_free(lv2_freewheeling);
3222 lilv_node_free(lv2_toggled);
3223 lilv_node_free(lv2_sampleRate);
3224 lilv_node_free(lv2_reportsLatency);
3225 lilv_node_free(lv2_index);
3226 lilv_node_free(lv2_integer);
3227 lilv_node_free(lv2_isSideChain);
3228 lilv_node_free(lv2_inPlaceBroken);
3229 lilv_node_free(lv2_OutputPort);
3230 lilv_node_free(lv2_InputPort);
3231 lilv_node_free(lv2_ControlPort);
3232 lilv_node_free(lv2_AudioPort);
3233 lilv_node_free(groups_group);
3234 lilv_node_free(groups_element);
3235 lilv_node_free(ext_rangeSteps);
3236 lilv_node_free(ext_notAutomatic);
3237 lilv_node_free(ext_causesArtifacts);
3238 lilv_node_free(ext_expensive);
3239 lilv_node_free(ext_notOnGUI);
3240 lilv_node_free(ext_logarithmic);
3241 lilv_node_free(ev_EventPort);
3242 lilv_node_free(atom_supports);
3243 lilv_node_free(atom_eventTransfer);
3244 lilv_node_free(atom_bufferType);
3245 lilv_node_free(atom_Sequence);
3246 lilv_node_free(atom_Chunk);
3247 lilv_node_free(atom_AtomPort);
3248 lilv_world_free(world);
3253 LV2World::load_bundled_plugins(bool verbose)
3255 if (!_bundle_checked) {
3257 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
3260 vector<string> plugin_objects;
3261 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
3262 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
3263 #ifdef PLATFORM_WINDOWS
3264 string uri = "file:///" + *x + "/";
3266 string uri = "file://" + *x + "/";
3268 LilvNode *node = lilv_new_uri(world, uri.c_str());
3269 lilv_world_load_bundle(world, node);
3270 lilv_node_free(node);
3273 lilv_world_load_all(world);
3274 _bundle_checked = true;
3278 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
3281 _plugin_uri = strdup(plugin_uri);
3284 LV2PluginInfo::~LV2PluginInfo()
3291 LV2PluginInfo::load(Session& session)
3295 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3296 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3297 if (!uri) { throw failed_constructor(); }
3298 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3299 if (!lp) { throw failed_constructor(); }
3300 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
3301 lilv_node_free(uri);
3302 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3304 } catch (failed_constructor& err) {
3305 return PluginPtr((Plugin*)0);
3311 std::vector<Plugin::PresetRecord>
3312 LV2PluginInfo::get_presets (bool /*user_only*/) const
3314 std::vector<Plugin::PresetRecord> p;
3315 #ifndef NO_PLUGIN_STATE
3316 const LilvPlugin* lp = NULL;
3319 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3320 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3321 if (!uri) { throw failed_constructor(); }
3322 lp = lilv_plugins_get_by_uri(plugins, uri);
3323 if (!lp) { throw failed_constructor(); }
3324 lilv_node_free(uri);
3325 } catch (failed_constructor& err) {
3329 // see LV2Plugin::find_presets
3330 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3331 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3332 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3334 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3335 LILV_FOREACH(nodes, i, presets) {
3336 const LilvNode* preset = lilv_nodes_get(presets, i);
3337 lilv_world_load_resource(_world.world, preset);
3338 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3339 bool userpreset = true; // TODO
3341 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
3342 lilv_node_free(name);
3345 lilv_nodes_free(presets);
3346 lilv_node_free(rdfs_label);
3347 lilv_node_free(pset_Preset);
3348 lilv_node_free(lv2_appliesTo);
3354 LV2PluginInfo::in_category (const std::string &c) const
3356 // TODO use untranslated lilv_plugin_get_class()
3357 // match gtk2_ardour/plugin_selector.cc
3358 if (category == c) {
3365 LV2PluginInfo::is_instrument () const
3367 if (category == "Instrument") {
3371 /* until we make sure that category remains untranslated in the lv2.ttl spec
3372 * and until most instruments also classify themselves as such, there's a 2nd check:
3374 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
3382 LV2PluginInfo::discover()
3385 world.load_bundled_plugins();
3386 _world.load_bundled_plugins(true);
3388 PluginInfoList* plugs = new PluginInfoList;
3389 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3391 LILV_FOREACH(plugins, i, plugins) {
3392 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3393 const LilvNode* pun = lilv_plugin_get_uri(p);
3395 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3397 LilvNode* name = lilv_plugin_get_name(p);
3398 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3399 warning << "Ignoring invalid LV2 plugin "
3400 << lilv_node_as_string(lilv_plugin_get_uri(p))
3405 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3406 warning << string_compose(
3407 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3408 lilv_node_as_string(name)) << endmsg;
3409 lilv_node_free(name);
3413 #ifdef HAVE_LV2_1_2_0
3414 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3415 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3416 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3418 warning << string_compose(
3419 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3420 lilv_node_as_string(name)) << endmsg;
3421 lilv_nodes_free(required_features);
3422 lilv_node_free(name);
3425 lilv_nodes_free(required_features);
3430 info->name = string(lilv_node_as_string(name));
3431 lilv_node_free(name);
3432 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3434 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3435 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3436 info->category = lilv_node_as_string(label);
3438 LilvNode* author_name = lilv_plugin_get_author_name(p);
3439 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3440 lilv_node_free(author_name);
3442 info->path = "/NOPATH"; // Meaningless for LV2
3444 /* count atom-event-ports that feature
3445 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3447 * TODO: nicely ask drobilla to make a lilv_ call for that
3449 int count_midi_out = 0;
3450 int count_midi_in = 0;
3451 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3452 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3453 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3454 LilvNodes* buffer_types = lilv_port_get_value(
3455 p, port, world.atom_bufferType);
3456 LilvNodes* atom_supports = lilv_port_get_value(
3457 p, port, world.atom_supports);
3459 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3460 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3461 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3464 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3468 lilv_nodes_free(buffer_types);
3469 lilv_nodes_free(atom_supports);
3473 info->n_inputs.set_audio(
3474 lilv_plugin_get_num_ports_of_class(
3475 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3476 info->n_inputs.set_midi(
3477 lilv_plugin_get_num_ports_of_class(
3478 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3481 info->n_outputs.set_audio(
3482 lilv_plugin_get_num_ports_of_class(
3483 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3484 info->n_outputs.set_midi(
3485 lilv_plugin_get_num_ports_of_class(
3486 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3489 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3490 info->index = 0; // Meaningless for LV2
3492 plugs->push_back(info);