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/session.h"
49 #include "ardour/tempo.h"
50 #include "ardour/types.h"
51 #include "ardour/utils.h"
52 #include "ardour/worker.h"
53 #include "ardour/search_paths.h"
58 #include <lilv/lilv.h>
60 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
61 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
62 #include "lv2/lv2plug.in/ns/ext/log/log.h"
63 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
64 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
65 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
66 #include "lv2/lv2plug.in/ns/ext/state/state.h"
67 #include "lv2/lv2plug.in/ns/ext/time/time.h"
68 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
69 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
70 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
71 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
72 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
74 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
75 #include "lv2/lv2plug.in/ns/ext/options/options.h"
78 #include "lv2_evbuf.h"
81 #include <suil/suil.h>
84 // Compatibility for old LV2
85 #ifndef LV2_ATOM_CONTENTS_CONST
86 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
87 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
89 #ifndef LV2_ATOM_BODY_CONST
90 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
92 #ifndef LV2_PATCH__property
93 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
95 #ifndef LV2_PATCH__value
96 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
98 #ifndef LV2_PATCH__writable
99 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
102 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
103 This needs to be roughly the number of cycles the UI will get around to
104 actually processing the traffic. Lower values are flakier but save memory.
106 static const size_t NBUFS = 4;
109 using namespace ARDOUR;
112 class LV2World : boost::noncopyable {
117 void load_bundled_plugins(bool verbose=false);
121 LilvNode* atom_AtomPort;
122 LilvNode* atom_Chunk;
123 LilvNode* atom_Sequence;
124 LilvNode* atom_bufferType;
125 LilvNode* atom_eventTransfer;
126 LilvNode* atom_supports;
127 LilvNode* ev_EventPort;
128 LilvNode* ext_logarithmic;
129 LilvNode* ext_notOnGUI;
130 LilvNode* ext_expensive;
131 LilvNode* ext_causesArtifacts;
132 LilvNode* ext_notAutomatic;
133 LilvNode* ext_rangeSteps;
134 LilvNode* lv2_AudioPort;
135 LilvNode* lv2_ControlPort;
136 LilvNode* lv2_InputPort;
137 LilvNode* lv2_OutputPort;
138 LilvNode* lv2_enumeration;
139 LilvNode* lv2_freewheeling;
140 LilvNode* lv2_inPlaceBroken;
141 LilvNode* lv2_isSideChain;
142 LilvNode* lv2_integer;
143 LilvNode* lv2_default;
144 LilvNode* lv2_minimum;
145 LilvNode* lv2_maximum;
146 LilvNode* lv2_reportsLatency;
147 LilvNode* lv2_sampleRate;
148 LilvNode* lv2_toggled;
149 LilvNode* midi_MidiEvent;
150 LilvNode* rdfs_comment;
151 LilvNode* rdfs_label;
152 LilvNode* rdfs_range;
153 LilvNode* rsz_minimumSize;
154 LilvNode* time_Position;
156 LilvNode* ui_external;
157 LilvNode* ui_externalkx;
160 LilvNode* units_unit;
161 LilvNode* units_render;
162 LilvNode* units_midiNote;
163 LilvNode* patch_writable;
164 LilvNode* patch_Message;
165 #ifdef HAVE_LV2_1_2_0
166 LilvNode* bufz_powerOf2BlockLength;
167 LilvNode* bufz_fixedBlockLength;
168 LilvNode* bufz_nominalBlockLength;
171 #ifdef HAVE_LV2_1_10_0
173 LilvNode* atom_float;
174 LilvNode* atom_object; // new in 1.8
175 LilvNode* atom_vector;
178 LilvNode* lv2_noSampleAccurateCtrl;
179 LilvNode* auto_can_write_automatation; // lv2:optionalFeature
180 LilvNode* auto_automation_control; // atom:supports
181 LilvNode* auto_automation_controlled; // lv2:portProperty
182 LilvNode* auto_automation_controller; // lv2:portProperty
186 bool _bundle_checked;
189 static LV2World _world;
191 /* worker extension */
193 /** Called by the plugin to schedule non-RT work. */
194 static LV2_Worker_Status
195 work_schedule(LV2_Worker_Schedule_Handle handle,
199 LV2Plugin* plugin = (LV2Plugin*)handle;
200 if (plugin->session().engine().freewheeling()) {
201 // Freewheeling, do the work immediately in this (audio) thread
202 return (LV2_Worker_Status)plugin->work(size, data);
204 // Enqueue message for the worker thread
205 return plugin->worker()->schedule(size, data) ?
206 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
210 /** Called by the plugin to respond to non-RT work. */
211 static LV2_Worker_Status
212 work_respond(LV2_Worker_Respond_Handle handle,
216 LV2Plugin* plugin = (LV2Plugin*)handle;
217 if (plugin->session().engine().freewheeling()) {
218 // Freewheeling, respond immediately in this (audio) thread
219 return (LV2_Worker_Status)plugin->work_response(size, data);
221 // Enqueue response for the worker
222 return plugin->worker()->respond(size, data) ?
223 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
228 /* inline display extension */
230 queue_draw (LV2_Inline_Display_Handle handle)
232 LV2Plugin* plugin = (LV2Plugin*)handle;
233 plugin->QueueDraw(); /* EMIT SIGNAL */
240 log_vprintf(LV2_Log_Handle /*handle*/,
246 const int ret = g_vasprintf(&str, fmt, args);
247 /* strip trailing whitespace */
248 while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
249 str[strlen (str) - 1] = '\0';
251 if (strlen (str) == 0) {
255 if (type == URIMap::instance().urids.log_Error) {
256 error << str << endmsg;
257 } else if (type == URIMap::instance().urids.log_Warning) {
258 warning << str << endmsg;
259 } else if (type == URIMap::instance().urids.log_Note) {
260 info << str << endmsg;
262 // TODO: Toggleable log:Trace message support
267 log_printf(LV2_Log_Handle handle,
269 const char* fmt, ...)
273 const int ret = log_vprintf(handle, type, fmt, args);
278 struct LV2Plugin::Impl {
279 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
281 #ifdef HAVE_LV2_1_2_0
286 #ifdef HAVE_LV2_1_2_0
294 /** Find the LV2 input port with the given designation.
295 * If found, bufptrs[port_index] will be set to bufptr.
297 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
299 const LilvPlugin* plugin;
301 const LilvNode* ui_type;
304 LilvInstance* instance;
305 const LV2_Worker_Interface* work_iface;
306 #ifdef HAVE_LV2_1_2_0
307 const LV2_Options_Interface* opts_iface;
310 LV2_Atom_Forge forge;
311 LV2_Atom_Forge ui_forge;
312 int32_t block_length;
313 #ifdef HAVE_LV2_1_2_0
314 LV2_Options_Option* options;
317 LV2_Inline_Display* queue_draw;
321 LV2Plugin::LV2Plugin (AudioEngine& engine,
323 const void* c_plugin,
325 : Plugin (engine, session)
331 , _patch_port_in_index((uint32_t)-1)
332 , _patch_port_out_index((uint32_t)-1)
333 , _uri_map(URIMap::instance())
334 , _no_sample_accurate_ctrl (false)
336 init(c_plugin, rate);
339 LV2Plugin::LV2Plugin (const LV2Plugin& other)
345 , _insert_id(other._insert_id)
346 , _patch_port_in_index((uint32_t)-1)
347 , _patch_port_out_index((uint32_t)-1)
348 , _uri_map(URIMap::instance())
349 , _no_sample_accurate_ctrl (false)
351 init(other._impl->plugin, other._sample_rate);
353 for (uint32_t i = 0; i < parameter_count(); ++i) {
354 _control_data[i] = other._shadow_data[i];
355 _shadow_data[i] = other._shadow_data[i];
360 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
362 DEBUG_TRACE(DEBUG::LV2, "init\n");
364 _impl->plugin = (const LilvPlugin*)c_plugin;
366 _impl->ui_type = NULL;
371 _atom_ev_buffers = 0;
373 _bpm_control_port = 0;
374 _freewheel_control_port = 0;
375 _latency_control_port = 0;
376 _next_cycle_start = std::numeric_limits<framepos_t>::max();
377 _next_cycle_speed = 1.0;
378 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
380 _was_activated = false;
381 _has_state_interface = false;
382 _can_write_automation = false;
384 _current_latency = 0;
385 _impl->block_length = _session.get_block_size();
387 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
388 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
389 _make_path_feature.URI = LV2_STATE__makePath;
390 _log_feature.URI = LV2_LOG__log;
391 _work_schedule_feature.URI = LV2_WORKER__schedule;
392 _work_schedule_feature.data = NULL;
393 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
394 _def_state_feature.data = NULL;
396 const LilvPlugin* plugin = _impl->plugin;
398 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
399 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
400 _has_state_interface =
401 // What plugins should have (lv2:extensionData state:Interface)
402 lilv_plugin_has_extension_data(plugin, state_iface_uri)
403 // What some outdated/incorrect ones have
404 || lilv_plugin_has_feature(plugin, state_uri);
405 lilv_node_free(state_uri);
406 lilv_node_free(state_iface_uri);
408 _features = (LV2_Feature**)calloc(12, sizeof(LV2_Feature*));
409 _features[0] = &_instance_access_feature;
410 _features[1] = &_data_access_feature;
411 _features[2] = &_make_path_feature;
412 _features[3] = _uri_map.uri_map_feature();
413 _features[4] = _uri_map.urid_map_feature();
414 _features[5] = _uri_map.urid_unmap_feature();
415 _features[6] = &_log_feature;
417 unsigned n_features = 7;
418 #ifdef HAVE_LV2_1_2_0
419 _features[n_features++] = &_def_state_feature;
422 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
423 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
426 _impl->queue_draw = (LV2_Inline_Display*)
427 malloc (sizeof(LV2_Inline_Display));
428 _impl->queue_draw->handle = this;
429 _impl->queue_draw->queue_draw = queue_draw;
431 _queue_draw_feature.URI = LV2_INLINEDISPLAY__queue_draw;
432 _queue_draw_feature.data = _impl->queue_draw;
433 _features[n_features++] = &_queue_draw_feature;
436 #ifdef HAVE_LV2_1_2_0
437 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
438 static const int32_t _min_block_length = 1; // may happen during split-cycles
439 static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
440 /* Consider updating max-block-size whenever the buffersize changes.
441 * It requires re-instantiating the plugin (which is a non-realtime operation),
442 * so it should be done lightly and only for plugins that require it.
444 * given that the block-size can change at any time (split-cycles) ardour currently
445 * does not support plugins that require bufz_fixedBlockLength.
447 LV2_Options_Option options[] = {
448 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
449 sizeof(int32_t), atom_Int, &_min_block_length },
450 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
451 sizeof(int32_t), atom_Int, &_max_block_length },
452 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
453 sizeof(int32_t), atom_Int, &_seq_size },
454 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
455 sizeof(int32_t), atom_Int, &_impl->block_length },
456 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
459 _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
460 memcpy ((void*) _impl->options, (void*) options, sizeof (options));
462 _options_feature.URI = LV2_OPTIONS__options;
463 _options_feature.data = _impl->options;
464 _features[n_features++] = &_options_feature;
467 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
468 sizeof(LV2_State_Make_Path));
469 make_path->handle = this;
470 make_path->path = &lv2_state_make_path;
471 _make_path_feature.data = make_path;
473 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
475 log->printf = &log_printf;
476 log->vprintf = &log_vprintf;
477 _log_feature.data = log;
479 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
480 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
481 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
482 sizeof(LV2_Worker_Schedule));
483 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
484 _worker = new Worker(this, buf_size);
485 schedule->handle = this;
486 schedule->schedule_work = work_schedule;
487 _work_schedule_feature.data = schedule;
488 _features[n_features++] = &_work_schedule_feature;
490 lilv_node_free(worker_schedule);
492 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
493 _impl->name = lilv_plugin_get_name(plugin);
494 _impl->author = lilv_plugin_get_author_name(plugin);
496 if (_impl->instance == 0) {
497 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
498 throw failed_constructor();
501 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
502 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
503 _data_access_feature.data = &_data_access_extension_data;
505 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
506 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
507 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
508 LV2_WORKER__interface);
510 lilv_node_free(worker_iface_uri);
513 #ifdef HAVE_LV2_1_2_0
514 LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
515 if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
516 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
517 LV2_OPTIONS__interface);
519 lilv_node_free(options_iface_uri);
523 _display_interface = (const LV2_Inline_Display_Interface*)
524 extension_data (LV2_INLINEDISPLAY__interface);
527 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
528 error << string_compose(
529 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
530 lilv_node_as_string(_impl->name)) << endmsg;
531 lilv_node_free(_impl->name);
532 lilv_node_free(_impl->author);
533 throw failed_constructor();
536 #ifdef HAVE_LV2_1_2_0
537 LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
538 if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
539 lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
541 error << string_compose(
542 _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
543 lilv_node_as_string(_impl->name)) << endmsg;
544 lilv_node_free(_impl->name);
545 lilv_node_free(_impl->author);
546 lilv_nodes_free(required_features);
547 throw failed_constructor();
549 lilv_nodes_free(required_features);
553 LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
554 if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
555 _no_sample_accurate_ctrl = true;
557 if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
558 _can_write_automation = true;
560 lilv_nodes_free(optional_features);
563 #ifdef HAVE_LILV_0_16_0
564 // Load default state
565 LilvState* state = lilv_state_new_from_world(
566 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
567 if (state && _has_state_interface) {
568 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
570 lilv_state_free(state);
575 const uint32_t num_ports = this->num_ports();
576 for (uint32_t i = 0; i < num_ports; ++i) {
577 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
579 size_t minimumSize = 0;
581 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
582 flags |= PORT_OUTPUT;
583 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
586 error << string_compose(
587 "LV2: \"%1\" port %2 is neither input nor output",
588 lilv_node_as_string(_impl->name), i) << endmsg;
589 throw failed_constructor();
592 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
593 flags |= PORT_CONTROL;
594 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
596 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
598 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
599 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
600 LilvNodes* buffer_types = lilv_port_get_value(
601 _impl->plugin, port, _world.atom_bufferType);
602 LilvNodes* atom_supports = lilv_port_get_value(
603 _impl->plugin, port, _world.atom_supports);
605 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
606 flags |= PORT_SEQUENCE;
607 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
610 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
611 flags |= PORT_POSITION;
614 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
615 flags |= PORT_AUTOCTRL;
618 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
619 flags |= PORT_PATCHMSG;
620 if (flags & PORT_INPUT) {
621 _patch_port_in_index = i;
623 _patch_port_out_index = i;
627 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
628 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
629 if (min_size && lilv_node_is_int(min_size)) {
630 minimumSize = lilv_node_as_int(min_size);
632 lilv_nodes_free(min_size_v);
633 lilv_nodes_free(buffer_types);
634 lilv_nodes_free(atom_supports);
636 error << string_compose(
637 "LV2: \"%1\" port %2 has no known data type",
638 lilv_node_as_string(_impl->name), i) << endmsg;
639 throw failed_constructor();
642 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
643 if (lilv_port_has_property(_impl->plugin, port, _world.ext_causesArtifacts)) {
644 flags |= PORT_NOAUTO;
646 if (lilv_port_has_property(_impl->plugin, port, _world.ext_notAutomatic)) {
647 flags |= PORT_NOAUTO;
649 if (lilv_port_has_property(_impl->plugin, port, _world.ext_expensive)) {
650 flags |= PORT_NOAUTO;
654 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
655 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
656 flags |= PORT_CTRLED;
659 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controller)) {
660 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
661 flags |= PORT_CTRLER;
666 _port_flags.push_back(flags);
667 _port_minimumSize.push_back(minimumSize);
668 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
671 _control_data = new float[num_ports];
672 _shadow_data = new float[num_ports];
673 _defaults = new float[num_ports];
674 _ev_buffers = new LV2_Evbuf*[num_ports];
675 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
677 const bool latent = lilv_plugin_has_latency(plugin);
678 const uint32_t latency_index = (latent)
679 ? lilv_plugin_get_latency_port_index(plugin)
682 // Build an array of pointers to special parameter buffers
683 void*** params = new void**[num_ports];
684 for (uint32_t i = 0; i < num_ports; ++i) {
687 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
688 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
690 for (uint32_t i = 0; i < num_ports; ++i) {
691 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
692 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
694 // Store index in map so we can look up index by symbol
695 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
697 // Get range and default value if applicable
698 if (parameter_is_control(i)) {
700 lilv_port_get_range(plugin, port, &def, NULL, NULL);
701 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
702 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
703 _defaults[i] *= _session.frame_rate ();
707 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
709 if (latent && i == latency_index) {
711 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
712 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
713 _latency_control_port = &_control_data[i];
714 *_latency_control_port = 0;
717 if (parameter_is_input(i)) {
718 _shadow_data[i] = default_value(i);
720 *params[i] = (void*)&_shadow_data[i];
730 LilvUIs* uis = lilv_plugin_get_uis(plugin);
731 if (lilv_uis_size(uis) > 0) {
733 // Look for embeddable UI
734 LILV_FOREACH(uis, u, uis) {
735 const LilvUI* this_ui = lilv_uis_get(uis, u);
736 const LilvNode* this_ui_type = NULL;
737 if (lilv_ui_is_supported(this_ui,
741 // TODO: Multiple UI support
743 _impl->ui_type = this_ui_type;
748 // Look for Gtk native UI
749 LILV_FOREACH(uis, i, uis) {
750 const LilvUI* ui = lilv_uis_get(uis, i);
751 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
753 _impl->ui_type = _world.ui_GtkUI;
759 // If Gtk UI is not available, try to find external UI
761 LILV_FOREACH(uis, i, uis) {
762 const LilvUI* ui = lilv_uis_get(uis, i);
763 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
765 _impl->ui_type = _world.ui_external;
768 if (lilv_ui_is_a(ui, _world.ui_external)) {
770 _impl->ui_type = _world.ui_external;
776 load_supported_properties(_property_descriptors);
777 allocate_atom_event_buffers();
778 latency_compute_run();
782 LV2Plugin::set_block_size (pframes_t nframes)
784 #ifdef HAVE_LV2_1_2_0
785 if (_impl->opts_iface) {
786 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
787 _impl->block_length = nframes;
788 LV2_Options_Option block_size_option = {
789 LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
790 sizeof(int32_t), atom_Int, (void*)&_impl->block_length
792 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
799 LV2Plugin::requires_fixed_sized_buffers () const
801 /* This controls if Ardour will split the plugin's run()
802 * on automation events in order to pass sample-accurate automation
803 * via standard control-ports.
805 * When returning true Ardour will *not* sub-divide the process-cycle.
806 * Automation events that happen between cycle-start and cycle-end will be
807 * ignored (ctrl values are interpolated to cycle-start).
808 * NB. Atom Sequences are still sample accurate.
810 * Note: This does not guarantee a fixed block-size.
811 * e.g The process cycle may be split when looping, also
812 * the period-size may change any time: see set_block_size()
814 if (get_info()->n_inputs.n_midi() > 0) {
815 /* we don't yet implement midi buffer offsets (for split cycles).
816 * Also connect_and_run() also uses _session.transport_frame() directly
817 * (for BBT) which is not offset for plugin cycle split.
821 return _no_sample_accurate_ctrl;
824 LV2Plugin::~LV2Plugin ()
826 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
831 lilv_instance_free(_impl->instance);
832 lilv_state_free(_impl->state);
833 lilv_node_free(_impl->name);
834 lilv_node_free(_impl->author);
835 #ifdef HAVE_LV2_1_2_0
836 free(_impl->options);
839 free(_impl->queue_draw);
843 free(_log_feature.data);
844 free(_make_path_feature.data);
845 free(_work_schedule_feature.data);
851 if (_atom_ev_buffers) {
852 LV2_Evbuf** b = _atom_ev_buffers;
857 free(_atom_ev_buffers);
860 delete [] _control_data;
861 delete [] _shadow_data;
863 delete [] _ev_buffers;
868 LV2Plugin::is_external_ui() const
873 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
877 LV2Plugin::is_external_kx() const
882 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
886 LV2Plugin::ui_is_resizable () const
888 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
889 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
890 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
891 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
893 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
894 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
896 lilv_nodes_free(nrs_matches);
897 lilv_nodes_free(fs_matches);
902 return !fs_matches && !nrs_matches;
907 LV2Plugin::has_inline_display () {
908 return _display_interface ? true : false;
911 Plugin::Display_Image_Surface*
912 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
913 if (_display_interface) {
914 /* Plugin::Display_Image_Surface is identical to
915 * LV2_Inline_Display_Image_Surface */
916 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
923 LV2Plugin::unique_id() const
925 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
929 LV2Plugin::uri() const
931 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
935 LV2Plugin::label() const
937 return lilv_node_as_string(_impl->name);
941 LV2Plugin::name() const
943 return lilv_node_as_string(_impl->name);
947 LV2Plugin::maker() const
949 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
953 LV2Plugin::num_ports() const
955 return lilv_plugin_get_num_ports(_impl->plugin);
959 LV2Plugin::parameter_count() const
961 return lilv_plugin_get_num_ports(_impl->plugin);
965 LV2Plugin::default_value(uint32_t port)
967 return _defaults[port];
971 LV2Plugin::port_symbol(uint32_t index) const
973 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
975 error << name() << ": Invalid port index " << index << endmsg;
978 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
979 return lilv_node_as_string(sym);
983 LV2Plugin::port_index (const char* symbol) const
985 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
986 if (i != _port_indices.end()) {
989 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
995 LV2Plugin::set_parameter(uint32_t which, float val)
997 DEBUG_TRACE(DEBUG::LV2, string_compose(
998 "%1 set parameter %2 to %3\n", name(), which, val));
1000 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
1001 if (get_parameter (which) == val) {
1005 _shadow_data[which] = val;
1007 warning << string_compose(
1008 _("Illegal parameter number used with plugin \"%1\". "
1009 "This is a bug in either %2 or the LV2 plugin <%3>"),
1010 name(), PROGRAM_NAME, unique_id()) << endmsg;
1013 Plugin::set_parameter(which, val);
1017 LV2Plugin::get_parameter(uint32_t which) const
1019 if (parameter_is_input(which)) {
1020 return (float)_shadow_data[which];
1022 return (float)_control_data[which];
1028 LV2Plugin::get_docs() const
1030 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1032 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1033 lilv_nodes_free(comments);
1041 LV2Plugin::get_parameter_docs(uint32_t which) const
1043 LilvNodes* comments = lilv_port_get_value(
1045 lilv_plugin_get_port_by_index(_impl->plugin, which),
1046 _world.rdfs_comment);
1049 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1050 lilv_nodes_free(comments);
1058 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1061 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1062 if (parameter_is_control(x)) {
1074 LV2Plugin::extension_data(const char* uri) const
1076 return lilv_instance_get_extension_data(_impl->instance, uri);
1080 LV2Plugin::c_plugin()
1082 return _impl->plugin;
1088 return (const void*)_impl->ui;
1092 LV2Plugin::c_ui_type()
1094 return (const void*)_impl->ui_type;
1097 /** Directory for all plugin state. */
1099 LV2Plugin::plugin_dir() const
1101 if (!_plugin_state_dir.empty ()){
1102 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1104 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1108 /** Directory for files created by the plugin (except during save). */
1110 LV2Plugin::scratch_dir() const
1112 return Glib::build_filename(plugin_dir(), "scratch");
1115 /** Directory for snapshots of files in the scratch directory. */
1117 LV2Plugin::file_dir() const
1119 return Glib::build_filename(plugin_dir(), "files");
1122 /** Directory to save state snapshot version @c num into. */
1124 LV2Plugin::state_dir(unsigned num) const
1126 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1129 /** Implementation of state:makePath for files created at instantiation time.
1130 * Note this is not used for files created at save time (Lilv deals with that).
1133 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1136 LV2Plugin* me = (LV2Plugin*)handle;
1137 if (me->_insert_id == PBD::ID("0")) {
1138 warning << string_compose(
1139 "File path \"%1\" requested but LV2 %2 has no insert ID",
1140 path, me->name()) << endmsg;
1141 return g_strdup(path);
1144 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1145 const std::string dirname = Glib::path_get_dirname(abs_path);
1146 g_mkdir_with_parents(dirname.c_str(), 0744);
1148 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1151 return g_strndup(abs_path.c_str(), abs_path.length());
1155 LV2Plugin::add_state(XMLNode* root) const
1157 assert(_insert_id != PBD::ID("0"));
1163 for (uint32_t i = 0; i < parameter_count(); ++i) {
1164 if (parameter_is_input(i) && parameter_is_control(i)) {
1165 child = new XMLNode("Port");
1166 child->add_property("symbol", port_symbol(i));
1167 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1168 child->add_property("value", string(buf));
1169 root->add_child_nocopy(*child);
1173 if (!_plugin_state_dir.empty()) {
1174 root->add_property("template-dir", _plugin_state_dir);
1177 if (_has_state_interface) {
1178 // Provisionally increment state version and create directory
1179 const std::string new_dir = state_dir(++_state_version);
1180 g_mkdir_with_parents(new_dir.c_str(), 0744);
1182 LilvState* state = lilv_state_new_from_instance(
1185 _uri_map.urid_map(),
1186 scratch_dir().c_str(),
1188 _session.externals_dir().c_str(),
1191 const_cast<LV2Plugin*>(this),
1195 if (!_plugin_state_dir.empty()
1197 || !lilv_state_equals(state, _impl->state)) {
1198 lilv_state_save(_world.world,
1199 _uri_map.urid_map(),
1200 _uri_map.urid_unmap(),
1206 if (_plugin_state_dir.empty()) {
1207 // normal session save
1208 lilv_state_free(_impl->state);
1209 _impl->state = state;
1211 // template save (dedicated state-dir)
1212 lilv_state_free(state);
1215 // State is identical, decrement version and nuke directory
1216 lilv_state_free(state);
1217 PBD::remove_directory(new_dir);
1221 root->add_property("state-dir", string_compose("state%1", _state_version));
1225 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1227 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1229 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1231 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1232 lilv_nodes_free(vs);
1239 LV2Plugin::find_presets()
1241 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1242 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1243 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1245 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1246 LILV_FOREACH(nodes, i, presets) {
1247 const LilvNode* preset = lilv_nodes_get(presets, i);
1248 lilv_world_load_resource(_world.world, preset);
1249 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1250 bool userpreset = true; // TODO
1252 _presets.insert(std::make_pair(lilv_node_as_string(preset),
1253 Plugin::PresetRecord(
1254 lilv_node_as_string(preset),
1255 lilv_node_as_string(name),
1257 lilv_node_free(name);
1259 warning << string_compose(
1260 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1261 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1262 lilv_node_as_string(preset)) << endmsg;
1265 lilv_nodes_free(presets);
1267 lilv_node_free(rdfs_label);
1268 lilv_node_free(pset_Preset);
1269 lilv_node_free(lv2_appliesTo);
1273 set_port_value(const char* port_symbol,
1279 LV2Plugin* self = (LV2Plugin*)user_data;
1280 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1281 return; // TODO: Support non-float ports
1284 const uint32_t port_index = self->port_index(port_symbol);
1285 if (port_index != (uint32_t)-1) {
1286 self->set_parameter(port_index, *(const float*)value);
1291 LV2Plugin::load_preset(PresetRecord r)
1293 LilvWorld* world = _world.world;
1294 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1295 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1298 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1299 lilv_state_free(state);
1300 Plugin::load_preset(r);
1303 lilv_node_free(pset);
1308 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1313 LV2Plugin *plugin = (LV2Plugin *) user_data;
1315 uint32_t index = plugin->port_index(port_symbol);
1316 if (index != (uint32_t) -1) {
1317 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1319 *size = sizeof(float);
1320 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1321 value = &plugin->_shadow_data[index];
1333 LV2Plugin::do_save_preset(string name)
1335 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1336 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1337 const string base_name = legalize_for_uri(name);
1338 const string file_name = base_name + ".ttl";
1339 const string bundle = Glib::build_filename(
1340 Glib::get_home_dir(),
1341 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1343 #ifdef HAVE_LILV_0_21_3
1344 /* delete reference to old preset (if any) */
1345 const PresetRecord* r = preset_by_label(name);
1347 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1349 lilv_world_unload_resource (_world.world, pset);
1350 lilv_node_free(pset);
1355 LilvState* state = lilv_state_new_from_instance(
1358 _uri_map.urid_map(),
1359 scratch_dir().c_str(), // file_dir
1360 bundle.c_str(), // copy_dir
1361 bundle.c_str(), // link_dir
1362 bundle.c_str(), // save_dir
1363 lv2plugin_get_port_value, // get_value
1364 (void*)this, // user_data
1365 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1366 _features // features
1369 lilv_state_set_label(state, name.c_str());
1371 _world.world, // world
1372 _uri_map.urid_map(), // map
1373 _uri_map.urid_unmap(), // unmap
1375 NULL, // uri (NULL = use file URI)
1376 bundle.c_str(), // dir
1377 file_name.c_str() // filename
1380 lilv_state_free(state);
1382 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1383 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1384 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1385 #ifdef HAVE_LILV_0_21_3
1386 lilv_world_unload_resource(_world.world, node_preset);
1387 lilv_world_unload_bundle(_world.world, node_bundle);
1389 lilv_world_load_bundle(_world.world, node_bundle);
1390 lilv_world_load_resource(_world.world, node_preset);
1391 lilv_node_free(node_bundle);
1392 lilv_node_free(node_preset);
1393 lilv_node_free(plug_name);
1398 LV2Plugin::do_remove_preset(string name)
1400 #ifdef HAVE_LILV_0_21_3
1401 /* Look up preset record by label (FIXME: ick, label as ID) */
1402 const PresetRecord* r = preset_by_label(name);
1407 /* Load a LilvState for the preset. */
1408 LilvWorld* world = _world.world;
1409 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1410 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1412 lilv_node_free(pset);
1416 /* Unload preset from world. */
1417 lilv_world_unload_resource(world, pset);
1419 /* Delete it from the file system. This will remove the preset file and the entry
1420 from the manifest. If this results in an empty manifest (i.e. the
1421 preset is the only thing in the bundle), then the bundle is removed. */
1422 lilv_state_delete(world, state);
1424 lilv_state_free(state);
1425 lilv_node_free(pset);
1427 /* Without lilv_state_delete(), we could delete the preset file, but this
1428 would leave a broken bundle/manifest around, so the preset would still
1429 be visible, but broken. Naively deleting a bundle is too dangerous, so
1430 we simply do not support preset deletion with older Lilv */
1434 LV2Plugin::has_editor() const
1436 return _impl->ui != NULL;
1440 LV2Plugin::has_message_output() const
1442 for (uint32_t i = 0; i < num_ports(); ++i) {
1443 if ((_port_flags[i] & PORT_SEQUENCE) &&
1444 (_port_flags[i] & PORT_OUTPUT)) {
1452 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1456 const uint8_t* body)
1458 const uint32_t buf_size = sizeof(UIMessage) + size;
1459 vector<uint8_t> buf(buf_size);
1461 UIMessage* msg = (UIMessage*)&buf[0];
1463 msg->protocol = protocol;
1465 memcpy(msg + 1, body, size);
1467 return (dest->write(&buf[0], buf_size) == buf_size);
1471 LV2Plugin::write_from_ui(uint32_t index,
1474 const uint8_t* body)
1477 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1478 /* buffer data communication from plugin UI to plugin instance.
1479 * this buffer needs to potentially hold
1480 * (port's minimumSize) * (audio-periods) / (UI-periods)
1483 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1484 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1485 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1487 * it is NOT safe to overflow (msg.size will be misinterpreted)
1489 uint32_t bufsiz = 32768;
1490 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1491 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1493 rbs = max((size_t) bufsiz * 8, rbs);
1494 _from_ui = new RingBuffer<uint8_t>(rbs);
1497 if (!write_to(_from_ui, index, protocol, size, body)) {
1498 error << "Error writing from UI to plugin" << endmsg;
1505 LV2Plugin::write_to_ui(uint32_t index,
1508 const uint8_t* body)
1510 if (!write_to(_to_ui, index, protocol, size, body)) {
1511 error << "Error writing from plugin to UI" << endmsg;
1518 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1520 switch (value.type()) {
1521 case Variant::NOTHING:
1523 case Variant::BEATS:
1524 // No atom type for this, just forge a double
1525 lv2_atom_forge_double(forge, value.get_beats().to_double());
1528 lv2_atom_forge_bool(forge, value.get_bool());
1530 case Variant::DOUBLE:
1531 lv2_atom_forge_double(forge, value.get_double());
1533 case Variant::FLOAT:
1534 lv2_atom_forge_float(forge, value.get_float());
1537 lv2_atom_forge_int(forge, value.get_int());
1540 lv2_atom_forge_long(forge, value.get_long());
1543 lv2_atom_forge_path(
1544 forge, value.get_path().c_str(), value.get_path().size());
1546 case Variant::STRING:
1547 lv2_atom_forge_string(
1548 forge, value.get_string().c_str(), value.get_string().size());
1552 forge, value.get_uri().c_str(), value.get_uri().size());
1557 /** Get a variant type from a URI, return false iff no match found. */
1559 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1561 if (uri == LV2_ATOM__Bool) {
1562 type = Variant::BOOL;
1563 } else if (uri == LV2_ATOM__Double) {
1564 type = Variant::DOUBLE;
1565 } else if (uri == LV2_ATOM__Float) {
1566 type = Variant::FLOAT;
1567 } else if (uri == LV2_ATOM__Int) {
1568 type = Variant::INT;
1569 } else if (uri == LV2_ATOM__Long) {
1570 type = Variant::LONG;
1571 } else if (uri == LV2_ATOM__Path) {
1572 type = Variant::PATH;
1573 } else if (uri == LV2_ATOM__String) {
1574 type = Variant::STRING;
1575 } else if (uri == LV2_ATOM__URI) {
1576 type = Variant::URI;
1584 LV2Plugin::set_property(uint32_t key, const Variant& value)
1586 if (_patch_port_in_index == (uint32_t)-1) {
1587 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1589 } else if (value.type() == Variant::NOTHING) {
1590 error << "LV2: set_property called with void value" << endmsg;
1594 // Set up forge to write to temporary buffer on the stack
1595 LV2_Atom_Forge* forge = &_impl->ui_forge;
1596 LV2_Atom_Forge_Frame frame;
1597 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1599 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1601 // Serialize patch:Set message to set property
1602 #ifdef HAVE_LV2_1_10_0
1603 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1604 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1605 lv2_atom_forge_urid(forge, key);
1606 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1608 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1609 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1610 lv2_atom_forge_urid(forge, key);
1611 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1614 forge_variant(forge, value);
1616 // Write message to UI=>Plugin ring
1617 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1618 write_from_ui(_patch_port_in_index,
1619 _uri_map.urids.atom_eventTransfer,
1620 lv2_atom_total_size(atom),
1621 (const uint8_t*)atom);
1624 const ParameterDescriptor&
1625 LV2Plugin::get_property_descriptor(uint32_t id) const
1627 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1628 if (p != _property_descriptors.end()) {
1631 return Plugin::get_property_descriptor(id);
1635 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1637 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1638 desc.unit = ParameterDescriptor::MIDI_NOTE;
1639 } else if (lilv_nodes_contains(units, _world.units_db)) {
1640 desc.unit = ParameterDescriptor::DB;
1641 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1642 desc.unit = ParameterDescriptor::HZ;
1644 if (lilv_nodes_size(units) > 0) {
1645 const LilvNode* unit = lilv_nodes_get_first(units);
1646 LilvNode* render = get_value(lworld, unit, _world.units_render);
1648 desc.print_fmt = lilv_node_as_string(render);
1649 replace_all (desc.print_fmt, "%f", "%.2f");
1650 lilv_node_free(render);
1656 load_parameter_descriptor(LV2World& world,
1657 ParameterDescriptor& desc,
1658 Variant::Type datatype,
1659 const LilvNode* subject)
1661 LilvWorld* lworld = _world.world;
1662 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1663 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1664 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1665 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1666 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1668 desc.label = lilv_node_as_string(label);
1670 if (def && lilv_node_is_float(def)) {
1671 desc.normal = lilv_node_as_float(def);
1673 if (minimum && lilv_node_is_float(minimum)) {
1674 desc.lower = lilv_node_as_float(minimum);
1676 if (maximum && lilv_node_is_float(maximum)) {
1677 desc.upper = lilv_node_as_float(maximum);
1679 load_parameter_descriptor_units(lworld, desc, units);
1680 desc.datatype = datatype;
1681 desc.toggled |= datatype == Variant::BOOL;
1682 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1683 desc.update_steps();
1685 lilv_nodes_free(units);
1686 lilv_node_free(label);
1687 lilv_node_free(def);
1688 lilv_node_free(minimum);
1689 lilv_node_free(maximum);
1693 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1695 LilvWorld* lworld = _world.world;
1696 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1697 LilvNodes* properties = lilv_world_find_nodes(
1698 lworld, subject, _world.patch_writable, NULL);
1699 LILV_FOREACH(nodes, p, properties) {
1700 // Get label and range
1701 const LilvNode* prop = lilv_nodes_get(properties, p);
1702 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1704 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1705 lilv_node_as_uri(prop)) << endmsg;
1709 // Convert range to variant type (TODO: support for multiple range types)
1710 Variant::Type datatype;
1711 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1712 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1713 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1717 // Add description to result
1718 ParameterDescriptor desc;
1719 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1720 desc.datatype = datatype;
1721 load_parameter_descriptor(_world, desc, datatype, prop);
1722 descs.insert(std::make_pair(desc.key, desc));
1724 lilv_node_free(range);
1726 lilv_nodes_free(properties);
1730 LV2Plugin::announce_property_values()
1732 if (_patch_port_in_index == (uint32_t)-1) {
1736 // Set up forge to write to temporary buffer on the stack
1737 LV2_Atom_Forge* forge = &_impl->ui_forge;
1738 LV2_Atom_Forge_Frame frame;
1739 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1741 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1743 // Serialize patch:Get message with no subject (implicitly plugin instance)
1744 #ifdef HAVE_LV2_1_10_0
1745 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1747 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1750 // Write message to UI=>Plugin ring
1751 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1752 write_from_ui(_patch_port_in_index,
1753 _uri_map.urids.atom_eventTransfer,
1754 lv2_atom_total_size(atom),
1755 (const uint8_t*)atom);
1759 LV2Plugin::enable_ui_emission()
1762 /* see note in LV2Plugin::write_from_ui() */
1763 uint32_t bufsiz = 32768;
1764 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1765 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1767 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1768 rbs = max((size_t) bufsiz * 8, rbs);
1769 _to_ui = new RingBuffer<uint8_t>(rbs);
1774 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1780 uint32_t read_space = _to_ui->read_space();
1781 while (read_space > sizeof(UIMessage)) {
1783 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1784 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1787 vector<uint8_t> body(msg.size);
1788 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1789 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1793 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1795 read_space -= sizeof(msg) + msg.size;
1800 LV2Plugin::work(uint32_t size, const void* data)
1802 return _impl->work_iface->work(
1803 _impl->instance->lv2_handle, work_respond, this, size, data);
1807 LV2Plugin::work_response(uint32_t size, const void* data)
1809 return _impl->work_iface->work_response(
1810 _impl->instance->lv2_handle, size, data);
1814 LV2Plugin::set_insert_id(PBD::ID id)
1816 if (_insert_id == "0") {
1818 } else if (_insert_id != id) {
1819 lilv_state_free(_impl->state);
1820 _impl->state = NULL;
1826 LV2Plugin::set_state_dir (const std::string& d)
1828 _plugin_state_dir = d;
1832 LV2Plugin::set_state(const XMLNode& node, int version)
1835 XMLProperty const * prop;
1836 XMLNodeConstIterator iter;
1843 if (node.name() != state_node_name()) {
1844 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1848 #ifndef NO_PLUGIN_STATE
1850 if (version < 3000) {
1851 nodes = node.children("port");
1853 nodes = node.children("Port");
1856 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1860 if ((prop = child->property("symbol")) != 0) {
1861 sym = prop->value().c_str();
1863 warning << _("LV2: port has no symbol, ignored") << endmsg;
1867 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1869 if (i != _port_indices.end()) {
1870 port_id = i->second;
1872 warning << _("LV2: port has unknown index, ignored") << endmsg;
1876 if ((prop = child->property("value")) != 0) {
1877 value = prop->value().c_str();
1879 warning << _("LV2: port has no value, ignored") << endmsg;
1883 set_parameter(port_id, atof(value));
1886 if ((prop = node.property("template-dir")) != 0) {
1887 set_state_dir (prop->value ());
1891 if ((prop = node.property("state-dir")) != 0) {
1892 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1893 error << string_compose(
1894 "LV2: failed to parse state version from \"%1\"",
1895 prop->value()) << endmsg;
1898 std::string state_file = Glib::build_filename(
1900 Glib::build_filename(prop->value(), "state.ttl"));
1902 LilvState* state = lilv_state_new_from_file(
1903 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1905 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1906 lilv_state_free(_impl->state);
1907 _impl->state = state;
1910 if (!_plugin_state_dir.empty ()) {
1911 // force save with session, next time (increment counter)
1912 lilv_state_free (_impl->state);
1913 _impl->state = NULL;
1917 latency_compute_run();
1920 return Plugin::set_state(node, version);
1924 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1926 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1928 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1933 LilvNodes* portunits;
1934 LilvNode *def, *min, *max;
1935 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1936 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1938 LilvNode* steps = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
1940 // TODO: Once we can rely on lilv 0.18.0 being present,
1941 // load_parameter_descriptor() can be used for ports as well
1942 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1943 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1944 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1945 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1946 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1947 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1948 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1949 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1950 load_parameter_descriptor_units(_world.world, desc, portunits);
1952 if (desc.sr_dependent) {
1953 desc.lower *= _session.frame_rate ();
1954 desc.upper *= _session.frame_rate ();
1957 desc.min_unbound = false; // TODO: LV2 extension required
1958 desc.max_unbound = false; // TODO: LV2 extension required
1960 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1961 desc.scale_points = get_scale_points(which);
1963 desc.update_steps();
1966 //override auto-calculated steps in update_steps()
1967 float s = lilv_node_as_float (steps);
1968 const float delta = desc.upper - desc.lower;
1970 desc.step = desc.smallstep = (delta / s);
1971 desc.largestep = std::min ((delta / 5.0f), 10.f * desc.smallstep);
1973 if (desc.logarithmic) {
1974 // TODO marry AutomationControl::internal_to_interface () with
1975 // http://lv2plug.in/ns/ext/port-props/#rangeSteps
1976 desc.smallstep = desc.smallstep / logf(s);
1977 desc.step = desc.step / logf(s);
1978 desc.largestep = desc.largestep / logf(s);
1979 } else if (desc.integer_step) {
1980 desc.smallstep = 1.0;
1981 desc.step = std::max(1.f, rintf (desc.step));
1982 desc.largestep = std::max(1.f, rintf (desc.largestep));
1984 DEBUG_TRACE(DEBUG::LV2, string_compose("parameter %1 small: %2, step: %3 largestep: %4\n",
1985 which, desc.smallstep, desc.step, desc.largestep));
1989 lilv_node_free(def);
1990 lilv_node_free(min);
1991 lilv_node_free(max);
1992 lilv_node_free(steps);
1993 lilv_nodes_free(portunits);
1998 Plugin::IOPortDescription
1999 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2001 PortFlags match = 0;
2003 case DataType::AUDIO:
2006 case DataType::MIDI:
2007 match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2010 return Plugin::IOPortDescription ("?");
2014 match |= PORT_INPUT;
2016 match |= PORT_OUTPUT;
2020 uint32_t idx = UINT32_MAX;
2022 uint32_t const num_ports = parameter_count();
2023 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2024 PortFlags flags = _port_flags[port_index];
2025 if ((flags & match) == match) {
2032 if (idx == UINT32_MAX) {
2033 return Plugin::IOPortDescription ("?");
2036 LilvNode* name = lilv_port_get_name(_impl->plugin,
2037 lilv_plugin_get_port_by_index(_impl->plugin, idx));
2038 Plugin::IOPortDescription iod (lilv_node_as_string (name));
2039 lilv_node_free(name);
2041 if (lilv_port_has_property(_impl->plugin,
2042 lilv_plugin_get_port_by_index(_impl->plugin, idx), _world.lv2_isSideChain)) {
2043 iod.is_sidechain = true;
2049 LV2Plugin::describe_parameter(Evoral::Parameter which)
2051 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2053 if (lilv_port_has_property(_impl->plugin,
2054 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2055 return X_("hidden");
2058 if (lilv_port_has_property(_impl->plugin,
2059 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2060 return X_("hidden");
2063 if (lilv_port_has_property(_impl->plugin,
2064 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2065 return X_("latency");
2068 LilvNode* name = lilv_port_get_name(_impl->plugin,
2069 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2070 string ret(lilv_node_as_string(name));
2071 lilv_node_free(name);
2079 LV2Plugin::max_latency () const
2081 return _max_latency;
2085 LV2Plugin::signal_latency() const
2087 if (_latency_control_port) {
2088 return (framecnt_t)floor(*_latency_control_port);
2094 set<Evoral::Parameter>
2095 LV2Plugin::automatable() const
2097 set<Evoral::Parameter> ret;
2099 for (uint32_t i = 0; i < parameter_count(); ++i) {
2100 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2101 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2105 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2106 p != _property_descriptors.end();
2108 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2114 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2116 if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2117 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2118 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2122 LV2Plugin::AutomationCtrlPtr
2123 LV2Plugin::get_automation_control (uint32_t i)
2125 if (_ctrl_map.find (i) == _ctrl_map.end()) {
2126 return AutomationCtrlPtr ();
2128 return _ctrl_map[i];
2132 LV2Plugin::activate()
2134 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2136 if (!_was_activated) {
2137 lilv_instance_activate(_impl->instance);
2138 _was_activated = true;
2143 LV2Plugin::deactivate()
2145 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2147 if (_was_activated) {
2148 lilv_instance_deactivate(_impl->instance);
2149 _was_activated = false;
2154 LV2Plugin::cleanup()
2156 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2159 lilv_instance_free(_impl->instance);
2160 _impl->instance = NULL;
2164 LV2Plugin::allocate_atom_event_buffers()
2166 /* reserve local scratch buffers for ATOM event-queues */
2167 const LilvPlugin* p = _impl->plugin;
2169 /* count non-MIDI atom event-ports
2170 * TODO: nicely ask drobilla to make a lilv_ call for that
2172 int count_atom_out = 0;
2173 int count_atom_in = 0;
2174 int minimumSize = 32768; // TODO use a per-port minimum-size
2175 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2176 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2177 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2178 LilvNodes* buffer_types = lilv_port_get_value(
2179 p, port, _world.atom_bufferType);
2180 LilvNodes* atom_supports = lilv_port_get_value(
2181 p, port, _world.atom_supports);
2183 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2184 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2187 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2190 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2191 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2192 if (min_size && lilv_node_is_int(min_size)) {
2193 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2195 lilv_nodes_free(min_size_v);
2197 lilv_nodes_free(buffer_types);
2198 lilv_nodes_free(atom_supports);
2202 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2203 name(), count_atom_in, count_atom_out));
2205 const int total_atom_buffers = (count_atom_in + count_atom_out);
2206 if (_atom_ev_buffers || total_atom_buffers == 0) {
2210 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2211 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2212 for (int i = 0; i < total_atom_buffers; ++i ) {
2213 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2214 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2216 _atom_ev_buffers[total_atom_buffers] = 0;
2220 /** Write an ardour position/time/tempo/meter as an LV2 event.
2221 * @return true on success.
2224 write_position(LV2_Atom_Forge* forge,
2226 const TempoMetric& t,
2227 Timecode::BBT_Time& bbt,
2229 framepos_t position,
2232 const URIMap::URIDs& urids = URIMap::instance().urids;
2234 uint8_t pos_buf[256];
2235 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2236 LV2_Atom_Forge_Frame frame;
2237 #ifdef HAVE_LV2_1_10_0
2238 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
2239 lv2_atom_forge_key(forge, urids.time_frame);
2240 lv2_atom_forge_long(forge, position);
2241 lv2_atom_forge_key(forge, urids.time_speed);
2242 lv2_atom_forge_float(forge, speed);
2243 lv2_atom_forge_key(forge, urids.time_barBeat);
2244 lv2_atom_forge_float(forge, bbt.beats - 1 +
2245 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2246 lv2_atom_forge_key(forge, urids.time_bar);
2247 lv2_atom_forge_long(forge, bbt.bars - 1);
2248 lv2_atom_forge_key(forge, urids.time_beatUnit);
2249 lv2_atom_forge_int(forge, t.meter().note_divisor());
2250 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2251 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2252 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2253 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2255 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2256 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2257 lv2_atom_forge_long(forge, position);
2258 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2259 lv2_atom_forge_float(forge, speed);
2260 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2261 lv2_atom_forge_float(forge, bbt.beats - 1 +
2262 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2263 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2264 lv2_atom_forge_long(forge, bbt.bars - 1);
2265 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2266 lv2_atom_forge_int(forge, t.meter().note_divisor());
2267 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2268 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2269 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2270 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2273 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
2274 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2275 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2276 (const uint8_t*)(atom + 1));
2280 LV2Plugin::connect_and_run(BufferSet& bufs,
2281 framepos_t start, framepos_t end, double speed,
2282 ChanMapping in_map, ChanMapping out_map,
2283 pframes_t nframes, framecnt_t offset)
2285 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2286 Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2288 cycles_t then = get_cycles();
2290 TempoMap& tmap = _session.tempo_map();
2291 Metrics::const_iterator metric_i = tmap.metrics_end();
2292 TempoMetric tmetric = tmap.metric_at(start, &metric_i);
2294 if (_freewheel_control_port) {
2295 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2298 if (_bpm_control_port) {
2299 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2303 if (_can_write_automation && start != _next_cycle_start) {
2304 // add guard-points after locating
2305 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2306 i->second->guard = true;
2311 ChanCount bufs_count;
2312 bufs_count.set(DataType::AUDIO, 1);
2313 bufs_count.set(DataType::MIDI, 1);
2314 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
2315 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2316 uint32_t const num_ports = parameter_count();
2317 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2319 uint32_t audio_in_index = 0;
2320 uint32_t audio_out_index = 0;
2321 uint32_t midi_in_index = 0;
2322 uint32_t midi_out_index = 0;
2323 uint32_t atom_port_index = 0;
2324 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2326 uint32_t index = nil_index;
2327 PortFlags flags = _port_flags[port_index];
2329 if (flags & PORT_AUDIO) {
2330 if (flags & PORT_INPUT) {
2331 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2333 ? bufs.get_audio(index).data(offset)
2334 : silent_bufs.get_audio(0).data(offset);
2336 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2338 ? bufs.get_audio(index).data(offset)
2339 : scratch_bufs.get_audio(0).data(offset);
2341 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2342 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2343 be necessary, but the mapping is illegal in some cases. Ideally
2344 that should be fixed, but this is easier...
2346 if (flags & PORT_MIDI) {
2347 if (flags & PORT_INPUT) {
2348 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2350 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2352 if (valid && bufs.count().n_midi() > index) {
2353 /* Note, ensure_lv2_bufsize() is not RT safe!
2354 * However free()/alloc() is only called if a
2355 * plugin requires a rsz:minimumSize buffersize
2356 * and the existing buffer if smaller.
2358 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2359 _ev_buffers[port_index] = bufs.get_lv2_midi(
2360 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2362 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2363 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2364 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2368 if (valid && (flags & PORT_INPUT)) {
2369 Timecode::BBT_Time bbt;
2370 if ((flags & PORT_POSITION)) {
2371 if (start != _next_cycle_start ||
2372 speed != _next_cycle_speed) {
2373 // Transport has changed, write position at cycle start
2374 bbt = tmap.bbt_at_frame (start);
2375 write_position(&_impl->forge, _ev_buffers[port_index],
2376 tmetric, bbt, speed, start, 0);
2380 // Get MIDI iterator range (empty range if no MIDI)
2381 MidiBuffer::iterator m = (index != nil_index)
2382 ? bufs.get_midi(index).begin()
2383 : silent_bufs.get_midi(0).end();
2384 MidiBuffer::iterator m_end = (index != nil_index)
2385 ? bufs.get_midi(index).end()
2388 // Now merge MIDI and any transport events into the buffer
2389 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2390 const framepos_t tend = end;
2392 while (m != m_end || (metric_i != tmap.metrics_end() &&
2393 (*metric_i)->frame() < tend)) {
2394 MetricSection* metric = (metric_i != tmap.metrics_end())
2396 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2397 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2398 if (ev.time() < nframes) {
2399 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2400 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2404 tmetric.set_metric(metric);
2405 bbt = tmap.bbt_at_pulse (metric->pulse());
2406 write_position(&_impl->forge, _ev_buffers[port_index],
2407 tmetric, bbt, speed,
2409 metric->frame() - start);
2413 } else if (!valid) {
2414 // Nothing we understand or care about, connect to scratch
2415 // see note for midi-buffer size above
2416 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2417 0, _port_minimumSize[port_index]);
2418 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2419 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2422 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2424 continue; // Control port, leave buffer alone
2426 lilv_instance_connect_port(_impl->instance, port_index, buf);
2429 // Read messages from UI and push into appropriate buffers
2431 uint32_t read_space = _from_ui->read_space();
2432 while (read_space > sizeof(UIMessage)) {
2434 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2435 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2438 vector<uint8_t> body(msg.size);
2439 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2440 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2443 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2444 LV2_Evbuf* buf = _ev_buffers[msg.index];
2445 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2446 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2447 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2448 (const uint8_t*)(atom + 1))) {
2449 error << "Failed to write data to LV2 event buffer\n";
2452 error << "Received unknown message type from UI" << endmsg;
2454 read_space -= sizeof(UIMessage) + msg.size;
2461 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2462 PortFlags flags = _port_flags[port_index];
2465 /* TODO ask drobilla about comment
2466 * "Make Ardour event buffers generic so plugins can communicate"
2467 * in libs/ardour/buffer_set.cc:310
2469 * ideally the user could choose which of the following two modes
2470 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2472 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2473 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2474 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2475 * for quite a while at least ;)
2477 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2478 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2479 const uint32_t buf_index = out_map.get(
2480 DataType::MIDI, midi_out_index++, &valid);
2482 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2485 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2486 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2487 const uint32_t buf_index = out_map.get(
2488 DataType::MIDI, midi_out_index++, &valid);
2490 bufs.flush_lv2_midi(true, buf_index);
2494 // Write messages to UI
2495 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2496 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2497 LV2_Evbuf* buf = _ev_buffers[port_index];
2498 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2499 lv2_evbuf_is_valid(i);
2500 i = lv2_evbuf_next(i)) {
2501 uint32_t frames, subframes, type, size;
2503 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2506 // Intercept Automation Write Events
2507 if ((flags & PORT_AUTOCTRL)) {
2508 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2509 if (atom->type == _uri_map.urids.atom_Blank ||
2510 atom->type == _uri_map.urids.atom_Object) {
2511 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2512 if (obj->body.otype == _uri_map.urids.auto_event) {
2513 // only if transport_rolling ??
2514 const LV2_Atom* parameter = NULL;
2515 const LV2_Atom* value = NULL;
2516 lv2_atom_object_get(obj,
2517 _uri_map.urids.auto_parameter, ¶meter,
2518 _uri_map.urids.auto_value, &value,
2520 if (parameter && value) {
2521 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2522 const float v = ((const LV2_Atom_Float*)value)->body;
2523 // -> add automation event..
2524 DEBUG_TRACE(DEBUG::LV2Automate,
2525 string_compose ("Event p: %1 t: %2 v: %3\n", p, frames, v));
2526 AutomationCtrlPtr c = get_automation_control (p);
2528 (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2530 framepos_t when = std::max ((framepos_t) 0, start + frames - _current_latency);
2531 assert (start + frames - _current_latency >= 0);
2534 c->ac->list()->add (when, v, true, true);
2536 c->ac->set_double (v, when, true);
2541 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2542 // TODO optional arguments, for now we assume the plugin
2543 // writes automation for its own inputs
2544 // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2545 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2546 if (_port_flags[i->first] & PORT_CTRLED) {
2547 DEBUG_TRACE(DEBUG::LV2Automate,
2548 string_compose ("Setup p: %1\n", i->first));
2549 i->second->ac->set_automation_state (Touch);
2553 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2554 // set [touched] parameters to "play" ??
2555 // allow plugin to change its mode (from analyze to apply)
2556 const LV2_Atom* parameter = NULL;
2557 const LV2_Atom* value = NULL;
2558 lv2_atom_object_get(obj,
2559 _uri_map.urids.auto_parameter, ¶meter,
2560 _uri_map.urids.auto_value, &value,
2562 if (parameter && value) {
2563 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2564 const float v = ((const LV2_Atom_Float*)value)->body;
2565 AutomationCtrlPtr c = get_automation_control (p);
2566 DEBUG_TRACE(DEBUG::LV2Automate,
2567 string_compose ("Finalize p: %1 v: %2\n", p, v));
2568 if (c && _port_flags[p] & PORT_CTRLER) {
2569 c->ac->set_value(v, Controllable::NoGroup);
2572 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2574 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2575 // guard will be false if an event was written
2576 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2577 DEBUG_TRACE(DEBUG::LV2Automate,
2578 string_compose ("Thin p: %1\n", i->first));
2579 i->second->ac->alist ()->thin (20);
2583 else if (obj->body.otype == _uri_map.urids.auto_start) {
2584 const LV2_Atom* parameter = NULL;
2585 lv2_atom_object_get(obj,
2586 _uri_map.urids.auto_parameter, ¶meter,
2589 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2590 AutomationCtrlPtr c = get_automation_control (p);
2591 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2593 c->ac->start_touch (std::max ((framepos_t)0, start - _current_latency));
2598 else if (obj->body.otype == _uri_map.urids.auto_end) {
2599 const LV2_Atom* parameter = NULL;
2600 lv2_atom_object_get(obj,
2601 _uri_map.urids.auto_parameter, ¶meter,
2604 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2605 AutomationCtrlPtr c = get_automation_control (p);
2606 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2608 c->ac->stop_touch (true, std::max ((framepos_t)0, start - _current_latency));
2616 // Intercept patch change messages to emit PropertyChanged signal
2617 if ((flags & PORT_PATCHMSG)) {
2618 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2619 if (atom->type == _uri_map.urids.atom_Blank ||
2620 atom->type == _uri_map.urids.atom_Object) {
2621 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2622 if (obj->body.otype == _uri_map.urids.patch_Set) {
2623 const LV2_Atom* property = NULL;
2624 const LV2_Atom* value = NULL;
2625 lv2_atom_object_get(obj,
2626 _uri_map.urids.patch_property, &property,
2627 _uri_map.urids.patch_value, &value,
2630 if (property && value &&
2631 property->type == _uri_map.urids.atom_URID &&
2632 value->type == _uri_map.urids.atom_Path) {
2633 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2634 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2636 // Emit PropertyChanged signal for UI
2637 // TODO: This should emit the control's Changed signal
2638 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2640 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2646 if (!_to_ui) continue;
2647 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2648 size + sizeof(LV2_Atom),
2649 data - sizeof(LV2_Atom));
2654 cycles_t now = get_cycles();
2655 set_cycles((uint32_t)(now - then));
2657 // Update expected transport information for next cycle so we can detect changes
2658 _next_cycle_speed = speed;
2659 _next_cycle_start = end;
2661 if (_latency_control_port) {
2662 framecnt_t new_latency = signal_latency ();
2663 if (_current_latency != new_latency) {
2664 LatencyChanged (_current_latency, new_latency); /* EMIT SIGNAL */
2666 _current_latency = new_latency;
2672 LV2Plugin::parameter_is_control(uint32_t param) const
2674 assert(param < _port_flags.size());
2675 return _port_flags[param] & PORT_CONTROL;
2679 LV2Plugin::parameter_is_audio(uint32_t param) const
2681 assert(param < _port_flags.size());
2682 return _port_flags[param] & PORT_AUDIO;
2686 LV2Plugin::parameter_is_event(uint32_t param) const
2688 assert(param < _port_flags.size());
2689 return _port_flags[param] & PORT_EVENT;
2693 LV2Plugin::parameter_is_output(uint32_t param) const
2695 assert(param < _port_flags.size());
2696 return _port_flags[param] & PORT_OUTPUT;
2700 LV2Plugin::parameter_is_input(uint32_t param) const
2702 assert(param < _port_flags.size());
2703 return _port_flags[param] & PORT_INPUT;
2707 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2710 if (param < parameter_count()) {
2711 snprintf(buf, len, "%.3f", get_parameter(param));
2718 boost::shared_ptr<ScalePoints>
2719 LV2Plugin::get_scale_points(uint32_t port_index) const
2721 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2722 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2724 boost::shared_ptr<ScalePoints> ret;
2729 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2731 LILV_FOREACH(scale_points, i, points) {
2732 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2733 const LilvNode* label = lilv_scale_point_get_label(p);
2734 const LilvNode* value = lilv_scale_point_get_value(p);
2735 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2736 ret->insert(make_pair(lilv_node_as_string(label),
2737 lilv_node_as_float(value)));
2741 lilv_scale_points_free(points);
2746 LV2Plugin::run(pframes_t nframes)
2748 uint32_t const N = parameter_count();
2749 for (uint32_t i = 0; i < N; ++i) {
2750 if (parameter_is_control(i) && parameter_is_input(i)) {
2751 _control_data[i] = _shadow_data[i];
2755 lilv_instance_run(_impl->instance, nframes);
2757 if (_impl->work_iface) {
2758 _worker->emit_responses();
2759 if (_impl->work_iface->end_run) {
2760 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2766 LV2Plugin::latency_compute_run()
2768 if (!_latency_control_port) {
2772 // Run the plugin so that it can set its latency parameter
2774 bool was_activated = _was_activated;
2777 uint32_t port_index = 0;
2778 uint32_t in_index = 0;
2779 uint32_t out_index = 0;
2781 // this is done in the main thread. non realtime.
2782 const framecnt_t bufsize = _engine.samples_per_cycle();
2783 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2785 memset(buffer, 0, sizeof(float) * bufsize);
2787 // FIXME: Ensure plugins can handle in-place processing
2791 while (port_index < parameter_count()) {
2792 if (parameter_is_audio(port_index)) {
2793 if (parameter_is_input(port_index)) {
2794 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2796 } else if (parameter_is_output(port_index)) {
2797 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2806 if (was_activated) {
2813 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2815 const LilvPort* port = NULL;
2816 LilvNode* designation = lilv_new_uri(_world.world, uri);
2817 port = lilv_plugin_get_port_by_designation(
2818 plugin, _world.lv2_InputPort, designation);
2819 lilv_node_free(designation);
2821 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2826 static bool lv2_filter (const string& str, void* /*arg*/)
2828 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2830 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2834 LV2World::LV2World()
2835 : world(lilv_world_new())
2836 , _bundle_checked(false)
2838 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2839 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2840 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2841 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2842 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2843 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2844 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2845 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2846 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2847 ext_expensive = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
2848 ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
2849 ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
2850 ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
2851 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2852 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2853 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2854 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2855 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2856 lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
2857 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2858 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2859 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2860 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2861 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2862 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2863 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2864 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2865 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2866 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2867 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2868 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2869 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2870 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2871 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2872 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2873 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2874 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2875 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2876 units_render = lilv_new_uri(world, LV2_UNITS__render);
2877 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2878 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2879 units_db = lilv_new_uri(world, LV2_UNITS__db);
2880 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2881 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2883 lv2_noSampleAccurateCtrl = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls");
2884 auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
2885 auto_automation_control = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
2886 auto_automation_controlled = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
2887 auto_automation_controller = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
2889 #ifdef HAVE_LV2_1_2_0
2890 bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2891 bufz_fixedBlockLength = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2892 bufz_nominalBlockLength = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2897 LV2World::~LV2World()
2902 #ifdef HAVE_LV2_1_2_0
2903 lilv_node_free(bufz_nominalBlockLength);
2904 lilv_node_free(bufz_fixedBlockLength);
2905 lilv_node_free(bufz_powerOf2BlockLength);
2908 lilv_node_free(lv2_noSampleAccurateCtrl);
2909 lilv_node_free(auto_can_write_automatation);
2910 lilv_node_free(auto_automation_control);
2911 lilv_node_free(auto_automation_controlled);
2912 lilv_node_free(auto_automation_controller);
2914 lilv_node_free(patch_Message);
2915 lilv_node_free(patch_writable);
2916 lilv_node_free(units_hz);
2917 lilv_node_free(units_midiNote);
2918 lilv_node_free(units_db);
2919 lilv_node_free(units_unit);
2920 lilv_node_free(units_render);
2921 lilv_node_free(ui_externalkx);
2922 lilv_node_free(ui_external);
2923 lilv_node_free(ui_GtkUI);
2924 lilv_node_free(time_Position);
2925 lilv_node_free(rsz_minimumSize);
2926 lilv_node_free(rdfs_comment);
2927 lilv_node_free(rdfs_label);
2928 lilv_node_free(rdfs_range);
2929 lilv_node_free(midi_MidiEvent);
2930 lilv_node_free(lv2_enumeration);
2931 lilv_node_free(lv2_freewheeling);
2932 lilv_node_free(lv2_toggled);
2933 lilv_node_free(lv2_sampleRate);
2934 lilv_node_free(lv2_reportsLatency);
2935 lilv_node_free(lv2_integer);
2936 lilv_node_free(lv2_isSideChain);
2937 lilv_node_free(lv2_inPlaceBroken);
2938 lilv_node_free(lv2_OutputPort);
2939 lilv_node_free(lv2_InputPort);
2940 lilv_node_free(lv2_ControlPort);
2941 lilv_node_free(lv2_AudioPort);
2942 lilv_node_free(ext_rangeSteps);
2943 lilv_node_free(ext_notAutomatic);
2944 lilv_node_free(ext_causesArtifacts);
2945 lilv_node_free(ext_expensive);
2946 lilv_node_free(ext_notOnGUI);
2947 lilv_node_free(ext_logarithmic);
2948 lilv_node_free(ev_EventPort);
2949 lilv_node_free(atom_supports);
2950 lilv_node_free(atom_eventTransfer);
2951 lilv_node_free(atom_bufferType);
2952 lilv_node_free(atom_Sequence);
2953 lilv_node_free(atom_Chunk);
2954 lilv_node_free(atom_AtomPort);
2955 lilv_world_free(world);
2960 LV2World::load_bundled_plugins(bool verbose)
2962 if (!_bundle_checked) {
2964 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2967 vector<string> plugin_objects;
2968 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2969 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2970 #ifdef PLATFORM_WINDOWS
2971 string uri = "file:///" + *x + "/";
2973 string uri = "file://" + *x + "/";
2975 LilvNode *node = lilv_new_uri(world, uri.c_str());
2976 lilv_world_load_bundle(world, node);
2977 lilv_node_free(node);
2980 lilv_world_load_all(world);
2981 _bundle_checked = true;
2985 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2988 _plugin_uri = strdup(plugin_uri);
2991 LV2PluginInfo::~LV2PluginInfo()
2998 LV2PluginInfo::load(Session& session)
3002 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3003 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3004 if (!uri) { throw failed_constructor(); }
3005 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3006 if (!lp) { throw failed_constructor(); }
3007 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
3008 lilv_node_free(uri);
3009 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3011 } catch (failed_constructor& err) {
3012 return PluginPtr((Plugin*)0);
3018 std::vector<Plugin::PresetRecord>
3019 LV2PluginInfo::get_presets (bool /*user_only*/) const
3021 std::vector<Plugin::PresetRecord> p;
3022 #ifndef NO_PLUGIN_STATE
3023 const LilvPlugin* lp = NULL;
3026 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3027 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3028 if (!uri) { throw failed_constructor(); }
3029 lp = lilv_plugins_get_by_uri(plugins, uri);
3030 if (!lp) { throw failed_constructor(); }
3031 lilv_node_free(uri);
3032 } catch (failed_constructor& err) {
3036 // see LV2Plugin::find_presets
3037 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3038 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3039 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3041 LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3042 LILV_FOREACH(nodes, i, presets) {
3043 const LilvNode* preset = lilv_nodes_get(presets, i);
3044 lilv_world_load_resource(_world.world, preset);
3045 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3046 bool userpreset = true; // TODO
3048 p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
3049 lilv_node_free(name);
3052 lilv_nodes_free(presets);
3053 lilv_node_free(rdfs_label);
3054 lilv_node_free(pset_Preset);
3055 lilv_node_free(lv2_appliesTo);
3061 LV2PluginInfo::in_category (const std::string &c) const
3063 // TODO use untranslated lilv_plugin_get_class()
3064 // match gtk2_ardour/plugin_selector.cc
3065 if (category == c) {
3072 LV2PluginInfo::is_instrument () const
3074 if (category == "Instrument") {
3078 /* until we make sure that category remains untranslated in the lv2.ttl spec
3079 * and until most instruments also classify themselves as such, there's a 2nd check:
3081 if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
3089 LV2PluginInfo::discover()
3092 world.load_bundled_plugins();
3093 _world.load_bundled_plugins(true);
3095 PluginInfoList* plugs = new PluginInfoList;
3096 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3098 LILV_FOREACH(plugins, i, plugins) {
3099 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3100 const LilvNode* pun = lilv_plugin_get_uri(p);
3102 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3104 LilvNode* name = lilv_plugin_get_name(p);
3105 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3106 warning << "Ignoring invalid LV2 plugin "
3107 << lilv_node_as_string(lilv_plugin_get_uri(p))
3112 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3113 warning << string_compose(
3114 _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3115 lilv_node_as_string(name)) << endmsg;
3116 lilv_node_free(name);
3120 #ifdef HAVE_LV2_1_2_0
3121 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3122 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3123 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3125 warning << string_compose(
3126 _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3127 lilv_node_as_string(name)) << endmsg;
3128 lilv_nodes_free(required_features);
3129 lilv_node_free(name);
3132 lilv_nodes_free(required_features);
3137 info->name = string(lilv_node_as_string(name));
3138 lilv_node_free(name);
3139 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3141 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3142 const LilvNode* label = lilv_plugin_class_get_label(pclass);
3143 info->category = lilv_node_as_string(label);
3145 LilvNode* author_name = lilv_plugin_get_author_name(p);
3146 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3147 lilv_node_free(author_name);
3149 info->path = "/NOPATH"; // Meaningless for LV2
3151 /* count atom-event-ports that feature
3152 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3154 * TODO: nicely ask drobilla to make a lilv_ call for that
3156 int count_midi_out = 0;
3157 int count_midi_in = 0;
3158 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3159 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
3160 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3161 LilvNodes* buffer_types = lilv_port_get_value(
3162 p, port, world.atom_bufferType);
3163 LilvNodes* atom_supports = lilv_port_get_value(
3164 p, port, world.atom_supports);
3166 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3167 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3168 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3171 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3175 lilv_nodes_free(buffer_types);
3176 lilv_nodes_free(atom_supports);
3180 info->n_inputs.set_audio(
3181 lilv_plugin_get_num_ports_of_class(
3182 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3183 info->n_inputs.set_midi(
3184 lilv_plugin_get_num_ports_of_class(
3185 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3188 info->n_outputs.set_audio(
3189 lilv_plugin_get_num_ports_of_class(
3190 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3191 info->n_outputs.set_midi(
3192 lilv_plugin_get_num_ports_of_class(
3193 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3196 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3197 info->index = 0; // Meaningless for LV2
3199 plugs->push_back(info);