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.
28 #include <glib/gstdio.h>
29 #include <glib/gprintf.h>
32 #include <boost/utility.hpp>
34 #include "pbd/file_utils.h"
35 #include "pbd/stl_delete.h"
36 #include "pbd/compose.h"
37 #include "pbd/error.h"
38 #include "pbd/xml++.h"
40 #include "libardour-config.h"
42 #include "ardour/audio_buffer.h"
43 #include "ardour/audioengine.h"
44 #include "ardour/debug.h"
45 #include "ardour/lv2_plugin.h"
46 #include "ardour/session.h"
47 #include "ardour/tempo.h"
48 #include "ardour/types.h"
49 #include "ardour/utils.h"
50 #include "ardour/worker.h"
51 #include "ardour/search_paths.h"
56 #include <lilv/lilv.h>
58 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
59 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
60 #include "lv2/lv2plug.in/ns/ext/log/log.h"
61 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
62 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
63 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
64 #include "lv2/lv2plug.in/ns/ext/state/state.h"
65 #include "lv2/lv2plug.in/ns/ext/time/time.h"
66 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
67 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
68 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
69 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
70 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
72 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
73 #include "lv2/lv2plug.in/ns/ext/options/options.h"
76 #include "lv2_evbuf.h"
79 #include <suil/suil.h>
82 // Compatibility for old LV2
83 #ifndef LV2_ATOM_CONTENTS_CONST
84 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
85 ((const void*)((const uint8_t*)(atom) + sizeof(type)))
87 #ifndef LV2_ATOM_BODY_CONST
88 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
90 #ifndef LV2_PATCH__property
91 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
93 #ifndef LV2_PATCH__value
94 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
96 #ifndef LV2_PATCH__writable
97 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
100 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
101 This needs to be roughly the number of cycles the UI will get around to
102 actually processing the traffic. Lower values are flakier but save memory.
104 static const size_t NBUFS = 4;
107 using namespace ARDOUR;
110 class LV2World : boost::noncopyable {
115 void load_bundled_plugins(bool verbose=false);
119 LilvNode* atom_AtomPort;
120 LilvNode* atom_Chunk;
121 LilvNode* atom_Sequence;
122 LilvNode* atom_bufferType;
123 LilvNode* atom_eventTransfer;
124 LilvNode* atom_supports;
125 LilvNode* ev_EventPort;
126 LilvNode* ext_logarithmic;
127 LilvNode* ext_notOnGUI;
128 LilvNode* lv2_AudioPort;
129 LilvNode* lv2_ControlPort;
130 LilvNode* lv2_InputPort;
131 LilvNode* lv2_OutputPort;
132 LilvNode* lv2_enumeration;
133 LilvNode* lv2_freewheeling;
134 LilvNode* lv2_inPlaceBroken;
135 LilvNode* lv2_integer;
136 LilvNode* lv2_default;
137 LilvNode* lv2_minimum;
138 LilvNode* lv2_maximum;
139 LilvNode* lv2_reportsLatency;
140 LilvNode* lv2_sampleRate;
141 LilvNode* lv2_toggled;
142 LilvNode* midi_MidiEvent;
143 LilvNode* rdfs_comment;
144 LilvNode* rdfs_label;
145 LilvNode* rdfs_range;
146 LilvNode* rsz_minimumSize;
147 LilvNode* time_Position;
149 LilvNode* ui_external;
150 LilvNode* ui_externalkx;
153 LilvNode* units_unit;
154 LilvNode* units_render;
155 LilvNode* units_midiNote;
156 LilvNode* patch_writable;
157 LilvNode* patch_Message;
160 bool _bundle_checked;
163 static LV2World _world;
165 /* worker extension */
167 /** Called by the plugin to schedule non-RT work. */
168 static LV2_Worker_Status
169 work_schedule(LV2_Worker_Schedule_Handle handle,
173 LV2Plugin* plugin = (LV2Plugin*)handle;
174 if (plugin->session().engine().freewheeling()) {
175 // Freewheeling, do the work immediately in this (audio) thread
176 return (LV2_Worker_Status)plugin->work(size, data);
178 // Enqueue message for the worker thread
179 return plugin->worker()->schedule(size, data) ?
180 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
184 /** Called by the plugin to respond to non-RT work. */
185 static LV2_Worker_Status
186 work_respond(LV2_Worker_Respond_Handle handle,
190 LV2Plugin* plugin = (LV2Plugin*)handle;
191 if (plugin->session().engine().freewheeling()) {
192 // Freewheeling, respond immediately in this (audio) thread
193 return (LV2_Worker_Status)plugin->work_response(size, data);
195 // Enqueue response for the worker
196 return plugin->worker()->respond(size, data) ?
197 LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
204 log_vprintf(LV2_Log_Handle /*handle*/,
210 const int ret = g_vasprintf(&str, fmt, args);
211 if (type == URIMap::instance().urids.log_Error) {
212 error << str << endmsg;
213 } else if (type == URIMap::instance().urids.log_Warning) {
214 warning << str << endmsg;
215 } else if (type == URIMap::instance().urids.log_Note) {
216 info << str << endmsg;
218 // TODO: Toggleable log:Trace message support
223 log_printf(LV2_Log_Handle handle,
225 const char* fmt, ...)
229 const int ret = log_vprintf(handle, type, fmt, args);
234 struct LV2Plugin::Impl {
235 Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
240 /** Find the LV2 input port with the given designation.
241 * If found, bufptrs[port_index] will be set to bufptr.
243 const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
245 const LilvPlugin* plugin;
247 const LilvNode* ui_type;
250 LilvInstance* instance;
251 const LV2_Worker_Interface* work_iface;
253 LV2_Atom_Forge forge;
254 LV2_Atom_Forge ui_forge;
257 LV2Plugin::LV2Plugin (AudioEngine& engine,
259 const void* c_plugin,
261 : Plugin (engine, session)
267 , _patch_port_in_index((uint32_t)-1)
268 , _patch_port_out_index((uint32_t)-1)
269 , _uri_map(URIMap::instance())
271 init(c_plugin, rate);
274 LV2Plugin::LV2Plugin (const LV2Plugin& other)
280 , _insert_id(other._insert_id)
281 , _patch_port_in_index((uint32_t)-1)
282 , _patch_port_out_index((uint32_t)-1)
283 , _uri_map(URIMap::instance())
285 init(other._impl->plugin, other._sample_rate);
287 for (uint32_t i = 0; i < parameter_count(); ++i) {
288 _control_data[i] = other._shadow_data[i];
289 _shadow_data[i] = other._shadow_data[i];
294 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
296 DEBUG_TRACE(DEBUG::LV2, "init\n");
298 _impl->plugin = (const LilvPlugin*)c_plugin;
300 _impl->ui_type = NULL;
305 _atom_ev_buffers = 0;
307 _bpm_control_port = 0;
308 _freewheel_control_port = 0;
309 _latency_control_port = 0;
310 _next_cycle_start = std::numeric_limits<framepos_t>::max();
311 _next_cycle_speed = 1.0;
312 _block_length = _engine.samples_per_cycle();
313 _seq_size = _engine.raw_buffer_size(DataType::MIDI);
315 _was_activated = false;
316 _has_state_interface = false;
318 _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
319 _data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
320 _make_path_feature.URI = LV2_STATE__makePath;
321 _log_feature.URI = LV2_LOG__log;
322 _work_schedule_feature.URI = LV2_WORKER__schedule;
323 _work_schedule_feature.data = NULL;
324 _def_state_feature.URI = LV2_STATE_PREFIX "loadDefaultState"; // Post LV2-1.2.0
325 _def_state_feature.data = NULL;
327 const LilvPlugin* plugin = _impl->plugin;
329 LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
330 LilvNode* state_uri = lilv_new_uri(_world.world, LV2_STATE_URI);
331 _has_state_interface =
332 // What plugins should have (lv2:extensionData state:Interface)
333 lilv_plugin_has_extension_data(plugin, state_iface_uri)
334 // What some outdated/incorrect ones have
335 || lilv_plugin_has_feature(plugin, state_uri);
336 lilv_node_free(state_uri);
337 lilv_node_free(state_iface_uri);
339 _features = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
340 _features[0] = &_instance_access_feature;
341 _features[1] = &_data_access_feature;
342 _features[2] = &_make_path_feature;
343 _features[3] = _uri_map.uri_map_feature();
344 _features[4] = _uri_map.urid_map_feature();
345 _features[5] = _uri_map.urid_unmap_feature();
346 _features[6] = &_log_feature;
348 unsigned n_features = 7;
349 #ifdef HAVE_LV2_1_2_0
350 _features[n_features++] = &_def_state_feature;
353 lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
354 lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
356 #ifdef HAVE_LV2_1_2_0
357 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
358 LV2_Options_Option options[] = {
359 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
360 sizeof(int32_t), atom_Int, &_block_length },
361 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
362 sizeof(int32_t), atom_Int, &_block_length },
363 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
364 sizeof(int32_t), atom_Int, &_seq_size },
365 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
368 _options_feature.URI = LV2_OPTIONS__options;
369 _options_feature.data = options;
370 _features[n_features++] = &_options_feature;
373 LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
374 sizeof(LV2_State_Make_Path));
375 make_path->handle = this;
376 make_path->path = &lv2_state_make_path;
377 _make_path_feature.data = make_path;
379 LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
381 log->printf = &log_printf;
382 log->vprintf = &log_vprintf;
383 _log_feature.data = log;
385 LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
386 if (lilv_plugin_has_feature(plugin, worker_schedule)) {
387 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
388 sizeof(LV2_Worker_Schedule));
389 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
390 _worker = new Worker(this, buf_size);
391 schedule->handle = this;
392 schedule->schedule_work = work_schedule;
393 _work_schedule_feature.data = schedule;
394 _features[n_features++] = &_work_schedule_feature;
396 lilv_node_free(worker_schedule);
398 _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
399 _impl->name = lilv_plugin_get_name(plugin);
400 _impl->author = lilv_plugin_get_author_name(plugin);
402 if (_impl->instance == 0) {
403 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
404 throw failed_constructor();
407 _instance_access_feature.data = (void*)_impl->instance->lv2_handle;
408 _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
409 _data_access_feature.data = &_data_access_extension_data;
411 LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
412 if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
413 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
414 LV2_WORKER__interface);
416 lilv_node_free(worker_iface_uri);
418 if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
419 error << string_compose(
420 _("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
421 lilv_node_as_string(_impl->name)) << endmsg;
422 lilv_node_free(_impl->name);
423 lilv_node_free(_impl->author);
424 throw failed_constructor();
427 #ifdef HAVE_LILV_0_16_0
428 // Load default state
429 LilvState* state = lilv_state_new_from_world(
430 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
431 if (state && _has_state_interface) {
432 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
438 const uint32_t num_ports = this->num_ports();
439 for (uint32_t i = 0; i < num_ports; ++i) {
440 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
442 size_t minimumSize = 0;
444 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
445 flags |= PORT_OUTPUT;
446 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
449 error << string_compose(
450 "LV2: \"%1\" port %2 is neither input nor output",
451 lilv_node_as_string(_impl->name), i) << endmsg;
452 throw failed_constructor();
455 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
456 flags |= PORT_CONTROL;
457 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
459 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
461 flags |= PORT_MIDI; // We assume old event API ports are for MIDI
462 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
463 LilvNodes* buffer_types = lilv_port_get_value(
464 _impl->plugin, port, _world.atom_bufferType);
465 LilvNodes* atom_supports = lilv_port_get_value(
466 _impl->plugin, port, _world.atom_supports);
468 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
469 flags |= PORT_SEQUENCE;
470 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
473 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
474 flags |= PORT_POSITION;
476 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
477 flags |= PORT_PATCHMSG;
478 if (flags & PORT_INPUT) {
479 _patch_port_in_index = i;
481 _patch_port_out_index = i;
485 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
486 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
487 if (min_size && lilv_node_is_int(min_size)) {
488 minimumSize = lilv_node_as_int(min_size);
490 lilv_nodes_free(min_size_v);
491 lilv_nodes_free(buffer_types);
492 lilv_nodes_free(atom_supports);
494 error << string_compose(
495 "LV2: \"%1\" port %2 has no known data type",
496 lilv_node_as_string(_impl->name), i) << endmsg;
497 throw failed_constructor();
500 _port_flags.push_back(flags);
501 _port_minimumSize.push_back(minimumSize);
504 _control_data = new float[num_ports];
505 _shadow_data = new float[num_ports];
506 _defaults = new float[num_ports];
507 _ev_buffers = new LV2_Evbuf*[num_ports];
508 memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
510 const bool latent = lilv_plugin_has_latency(plugin);
511 const uint32_t latency_index = (latent)
512 ? lilv_plugin_get_latency_port_index(plugin)
515 // Build an array of pointers to special parameter buffers
516 void*** params = new void**[num_ports];
517 for (uint32_t i = 0; i < num_ports; ++i) {
520 _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
521 _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
523 for (uint32_t i = 0; i < num_ports; ++i) {
524 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
525 const LilvNode* sym = lilv_port_get_symbol(plugin, port);
527 // Store index in map so we can look up index by symbol
528 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
530 // Get range and default value if applicable
531 if (parameter_is_control(i)) {
533 lilv_port_get_range(plugin, port, &def, NULL, NULL);
534 _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
535 if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
536 _defaults[i] *= _session.frame_rate ();
540 lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
542 if (latent && i == latency_index) {
543 _latency_control_port = &_control_data[i];
544 *_latency_control_port = 0;
547 if (parameter_is_input(i)) {
548 _shadow_data[i] = default_value(i);
550 *params[i] = (void*)&_shadow_data[i];
560 LilvUIs* uis = lilv_plugin_get_uis(plugin);
561 if (lilv_uis_size(uis) > 0) {
563 // Look for embeddable UI
564 LILV_FOREACH(uis, u, uis) {
565 const LilvUI* this_ui = lilv_uis_get(uis, u);
566 const LilvNode* this_ui_type = NULL;
567 if (lilv_ui_is_supported(this_ui,
571 // TODO: Multiple UI support
573 _impl->ui_type = this_ui_type;
578 // Look for Gtk native UI
579 LILV_FOREACH(uis, i, uis) {
580 const LilvUI* ui = lilv_uis_get(uis, i);
581 if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
583 _impl->ui_type = _world.ui_GtkUI;
589 // If Gtk UI is not available, try to find external UI
591 LILV_FOREACH(uis, i, uis) {
592 const LilvUI* ui = lilv_uis_get(uis, i);
593 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
595 _impl->ui_type = _world.ui_external;
598 if (lilv_ui_is_a(ui, _world.ui_external)) {
600 _impl->ui_type = _world.ui_external;
606 load_supported_properties(_property_descriptors);
607 allocate_atom_event_buffers();
608 latency_compute_run();
611 LV2Plugin::~LV2Plugin ()
613 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
618 lilv_instance_free(_impl->instance);
619 lilv_node_free(_impl->name);
620 lilv_node_free(_impl->author);
623 free(_make_path_feature.data);
624 free(_work_schedule_feature.data);
630 if (_atom_ev_buffers) {
631 LV2_Evbuf** b = _atom_ev_buffers;
636 free(_atom_ev_buffers);
639 delete [] _control_data;
640 delete [] _shadow_data;
641 delete [] _ev_buffers;
645 LV2Plugin::is_external_ui() const
650 return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
654 LV2Plugin::is_external_kx() const
659 return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
663 LV2Plugin::ui_is_resizable () const
665 const LilvNode* s = lilv_ui_get_uri(_impl->ui);
666 LilvNode* p = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
667 LilvNode* fs = lilv_new_uri(_world.world, LV2_UI__fixedSize);
668 LilvNode* nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
670 LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
671 LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
673 lilv_nodes_free(nrs_matches);
674 lilv_nodes_free(fs_matches);
679 return !fs_matches && !nrs_matches;
683 LV2Plugin::unique_id() const
685 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
689 LV2Plugin::uri() const
691 return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
695 LV2Plugin::label() const
697 return lilv_node_as_string(_impl->name);
701 LV2Plugin::name() const
703 return lilv_node_as_string(_impl->name);
707 LV2Plugin::maker() const
709 return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
713 LV2Plugin::num_ports() const
715 return lilv_plugin_get_num_ports(_impl->plugin);
719 LV2Plugin::parameter_count() const
721 return lilv_plugin_get_num_ports(_impl->plugin);
725 LV2Plugin::default_value(uint32_t port)
727 return _defaults[port];
731 LV2Plugin::port_symbol(uint32_t index) const
733 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
735 error << name() << ": Invalid port index " << index << endmsg;
738 const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
739 return lilv_node_as_string(sym);
743 LV2Plugin::port_index (const char* symbol) const
745 const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
746 if (i != _port_indices.end()) {
749 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
755 LV2Plugin::set_parameter(uint32_t which, float val)
757 DEBUG_TRACE(DEBUG::LV2, string_compose(
758 "%1 set parameter %2 to %3\n", name(), which, val));
760 if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
761 if (get_parameter (which) == val) {
765 _shadow_data[which] = val;
767 warning << string_compose(
768 _("Illegal parameter number used with plugin \"%1\". "
769 "This is a bug in either %2 or the LV2 plugin <%3>"),
770 name(), PROGRAM_NAME, unique_id()) << endmsg;
773 Plugin::set_parameter(which, val);
777 LV2Plugin::get_parameter(uint32_t which) const
779 if (parameter_is_input(which)) {
780 return (float)_shadow_data[which];
782 return (float)_control_data[which];
788 LV2Plugin::get_docs() const
790 LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
792 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
793 lilv_nodes_free(comments);
801 LV2Plugin::get_parameter_docs(uint32_t which) const
803 LilvNodes* comments = lilv_port_get_value(
805 lilv_plugin_get_port_by_index(_impl->plugin, which),
806 _world.rdfs_comment);
809 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
810 lilv_nodes_free(comments);
818 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
821 for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
822 if (parameter_is_control(x)) {
834 LV2Plugin::extension_data(const char* uri) const
836 return lilv_instance_get_extension_data(_impl->instance, uri);
840 LV2Plugin::c_plugin()
842 return _impl->plugin;
848 return (const void*)_impl->ui;
852 LV2Plugin::c_ui_type()
854 return (const void*)_impl->ui_type;
857 /** Directory for all plugin state. */
859 LV2Plugin::plugin_dir() const
861 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
864 /** Directory for files created by the plugin (except during save). */
866 LV2Plugin::scratch_dir() const
868 return Glib::build_filename(plugin_dir(), "scratch");
871 /** Directory for snapshots of files in the scratch directory. */
873 LV2Plugin::file_dir() const
875 return Glib::build_filename(plugin_dir(), "files");
878 /** Directory to save state snapshot version @c num into. */
880 LV2Plugin::state_dir(unsigned num) const
882 return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
885 /** Implementation of state:makePath for files created at instantiation time.
886 * Note this is not used for files created at save time (Lilv deals with that).
889 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
892 LV2Plugin* me = (LV2Plugin*)handle;
893 if (me->_insert_id == PBD::ID("0")) {
894 warning << string_compose(
895 "File path \"%1\" requested but LV2 %2 has no insert ID",
896 path, me->name()) << endmsg;
897 return g_strdup(path);
900 const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
901 const std::string dirname = Glib::path_get_dirname(abs_path);
902 g_mkdir_with_parents(dirname.c_str(), 0744);
904 DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
907 return g_strndup(abs_path.c_str(), abs_path.length());
911 LV2Plugin::add_state(XMLNode* root) const
913 assert(_insert_id != PBD::ID("0"));
917 LocaleGuard lg(X_("C"));
919 for (uint32_t i = 0; i < parameter_count(); ++i) {
920 if (parameter_is_input(i) && parameter_is_control(i)) {
921 child = new XMLNode("Port");
922 child->add_property("symbol", port_symbol(i));
923 snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
924 child->add_property("value", string(buf));
925 root->add_child_nocopy(*child);
929 if (_has_state_interface) {
930 // Provisionally increment state version and create directory
931 const std::string new_dir = state_dir(++_state_version);
932 g_mkdir_with_parents(new_dir.c_str(), 0744);
934 LilvState* state = lilv_state_new_from_instance(
938 scratch_dir().c_str(),
940 _session.externals_dir().c_str(),
943 const_cast<LV2Plugin*>(this),
947 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
948 lilv_state_save(_world.world,
950 _uri_map.urid_unmap(),
956 lilv_state_free(_impl->state);
957 _impl->state = state;
959 // State is identical, decrement version and nuke directory
960 lilv_state_free(state);
961 PBD::remove_directory(new_dir);
965 root->add_property("state-dir", string_compose("state%1", _state_version));
969 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
971 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
973 LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
975 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
983 LV2Plugin::find_presets()
985 LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
986 LilvNode* pset_Preset = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
987 LilvNode* rdfs_label = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
989 LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
990 LILV_FOREACH(nodes, i, presets) {
991 const LilvNode* preset = lilv_nodes_get(presets, i);
992 lilv_world_load_resource(_world.world, preset);
993 LilvNode* name = get_value(_world.world, preset, rdfs_label);
995 _presets.insert(std::make_pair(lilv_node_as_string(preset),
996 Plugin::PresetRecord(
997 lilv_node_as_string(preset),
998 lilv_node_as_string(name))));
999 lilv_node_free(name);
1001 warning << string_compose(
1002 _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1003 lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1004 lilv_node_as_string(preset)) << endmsg;
1007 lilv_nodes_free(presets);
1009 lilv_node_free(rdfs_label);
1010 lilv_node_free(pset_Preset);
1011 lilv_node_free(lv2_appliesTo);
1015 set_port_value(const char* port_symbol,
1021 LV2Plugin* self = (LV2Plugin*)user_data;
1022 if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1023 return; // TODO: Support non-float ports
1026 const uint32_t port_index = self->port_index(port_symbol);
1027 if (port_index != (uint32_t)-1) {
1028 self->set_parameter(port_index, *(const float*)value);
1033 LV2Plugin::load_preset(PresetRecord r)
1035 LilvWorld* world = _world.world;
1036 LilvNode* pset = lilv_new_uri(world, r.uri.c_str());
1037 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1040 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1041 lilv_state_free(state);
1042 Plugin::load_preset(r);
1045 lilv_node_free(pset);
1050 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1055 LV2Plugin *plugin = (LV2Plugin *) user_data;
1057 uint32_t index = plugin->port_index(port_symbol);
1058 if (index != (uint32_t) -1) {
1059 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1061 *size = sizeof(float);
1062 *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1063 value = &plugin->_shadow_data[index];
1075 LV2Plugin::do_save_preset(string name)
1077 const string base_name = legalize_for_uri(name);
1078 const string file_name = base_name + ".ttl";
1079 const string bundle = Glib::build_filename(
1080 Glib::get_home_dir(),
1081 Glib::build_filename(".lv2", base_name + ".lv2"));
1083 LilvState* state = lilv_state_new_from_instance(
1086 _uri_map.urid_map(),
1087 scratch_dir().c_str(), // file_dir
1088 bundle.c_str(), // copy_dir
1089 bundle.c_str(), // link_dir
1090 bundle.c_str(), // save_dir
1091 lv2plugin_get_port_value, // get_value
1092 (void*)this, // user_data
1093 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1094 _features // features
1097 lilv_state_set_label(state, name.c_str());
1099 _world.world, // world
1100 _uri_map.urid_map(), // map
1101 _uri_map.urid_unmap(), // unmap
1103 NULL, // uri (NULL = use file URI)
1104 bundle.c_str(), // dir
1105 file_name.c_str() // filename
1108 lilv_state_free(state);
1110 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1111 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1112 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1113 #ifdef HAVE_LILV_0_19_2
1114 lilv_world_unload_resource(_world.world, node_preset);
1115 lilv_world_unload_bundle(_world.world, node_bundle);
1117 lilv_world_load_bundle(_world.world, node_bundle);
1118 lilv_world_load_resource(_world.world, node_preset);
1119 lilv_node_free(node_bundle);
1120 lilv_node_free(node_preset);
1125 LV2Plugin::do_remove_preset(string name)
1127 string preset_file = Glib::build_filename(
1128 Glib::get_home_dir(),
1129 Glib::build_filename(
1130 Glib::build_filename(".lv2", "presets"),
1134 ::g_unlink(preset_file.c_str());
1138 LV2Plugin::has_editor() const
1140 return _impl->ui != NULL;
1144 LV2Plugin::has_message_output() const
1146 for (uint32_t i = 0; i < num_ports(); ++i) {
1147 if ((_port_flags[i] & PORT_SEQUENCE) &&
1148 (_port_flags[i] & PORT_OUTPUT)) {
1156 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1160 const uint8_t* body)
1162 const uint32_t buf_size = sizeof(UIMessage) + size;
1163 vector<uint8_t> buf(buf_size);
1165 UIMessage* msg = (UIMessage*)&buf[0];
1167 msg->protocol = protocol;
1169 memcpy(msg + 1, body, size);
1171 return (dest->write(&buf[0], buf_size) == buf_size);
1175 LV2Plugin::write_from_ui(uint32_t index,
1178 const uint8_t* body)
1181 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1182 /* buffer data communication from plugin UI to plugin instance.
1183 * this buffer needs to potentially hold
1184 * (port's minimumSize) * (audio-periods) / (UI-periods)
1187 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1188 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1189 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1191 * it is NOT safe to overflow (msg.size will be misinterpreted)
1193 uint32_t bufsiz = 32768;
1194 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1195 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1197 rbs = max((size_t) bufsiz * 8, rbs);
1198 _from_ui = new RingBuffer<uint8_t>(rbs);
1201 if (!write_to(_from_ui, index, protocol, size, body)) {
1202 error << "Error writing from UI to plugin" << endmsg;
1209 LV2Plugin::write_to_ui(uint32_t index,
1212 const uint8_t* body)
1214 if (!write_to(_to_ui, index, protocol, size, body)) {
1215 error << "Error writing from plugin to UI" << endmsg;
1222 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1224 switch (value.type()) {
1225 case Variant::NOTHING:
1227 case Variant::BEATS:
1228 // No atom type for this, just forge a double
1229 lv2_atom_forge_double(forge, value.get_beats().to_double());
1232 lv2_atom_forge_bool(forge, value.get_bool());
1234 case Variant::DOUBLE:
1235 lv2_atom_forge_double(forge, value.get_double());
1237 case Variant::FLOAT:
1238 lv2_atom_forge_float(forge, value.get_float());
1241 lv2_atom_forge_int(forge, value.get_int());
1244 lv2_atom_forge_long(forge, value.get_long());
1247 lv2_atom_forge_path(
1248 forge, value.get_path().c_str(), value.get_path().size());
1250 case Variant::STRING:
1251 lv2_atom_forge_string(
1252 forge, value.get_string().c_str(), value.get_string().size());
1256 forge, value.get_uri().c_str(), value.get_uri().size());
1261 /** Get a variant type from a URI, return false iff no match found. */
1263 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1265 if (uri == LV2_ATOM__Bool) {
1266 type = Variant::BOOL;
1267 } else if (uri == LV2_ATOM__Double) {
1268 type = Variant::DOUBLE;
1269 } else if (uri == LV2_ATOM__Float) {
1270 type = Variant::FLOAT;
1271 } else if (uri == LV2_ATOM__Int) {
1272 type = Variant::INT;
1273 } else if (uri == LV2_ATOM__Long) {
1274 type = Variant::LONG;
1275 } else if (uri == LV2_ATOM__Path) {
1276 type = Variant::PATH;
1277 } else if (uri == LV2_ATOM__String) {
1278 type = Variant::STRING;
1279 } else if (uri == LV2_ATOM__URI) {
1280 type = Variant::URI;
1288 LV2Plugin::set_property(uint32_t key, const Variant& value)
1290 if (_patch_port_in_index == (uint32_t)-1) {
1291 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1293 } else if (value.type() == Variant::NOTHING) {
1294 error << "LV2: set_property called with void value" << endmsg;
1298 // Set up forge to write to temporary buffer on the stack
1299 LV2_Atom_Forge* forge = &_impl->ui_forge;
1300 LV2_Atom_Forge_Frame frame;
1301 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1303 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1305 // Serialize patch:Set message to set property
1306 #ifdef HAVE_LV2_1_10_0
1307 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1308 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1309 lv2_atom_forge_urid(forge, key);
1310 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1312 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1313 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1314 lv2_atom_forge_urid(forge, key);
1315 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1318 forge_variant(forge, value);
1320 // Write message to UI=>Plugin ring
1321 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1322 write_from_ui(_patch_port_in_index,
1323 _uri_map.urids.atom_eventTransfer,
1324 lv2_atom_total_size(atom),
1325 (const uint8_t*)atom);
1328 const ParameterDescriptor&
1329 LV2Plugin::get_property_descriptor(uint32_t id) const
1331 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1332 if (p != _property_descriptors.end()) {
1335 return Plugin::get_property_descriptor(id);
1339 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1341 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1342 desc.unit = ParameterDescriptor::MIDI_NOTE;
1343 } else if (lilv_nodes_contains(units, _world.units_db)) {
1344 desc.unit = ParameterDescriptor::DB;
1345 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1346 desc.unit = ParameterDescriptor::HZ;
1348 if (lilv_nodes_size(units) > 0) {
1349 const LilvNode* unit = lilv_nodes_get_first(units);
1350 LilvNode* render = get_value(lworld, unit, _world.units_render);
1352 desc.print_fmt = lilv_node_as_string(render);
1353 lilv_node_free(render);
1359 load_parameter_descriptor(LV2World& world,
1360 ParameterDescriptor& desc,
1361 Variant::Type datatype,
1362 const LilvNode* subject)
1364 LilvWorld* lworld = _world.world;
1365 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1366 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1367 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1368 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1369 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1371 desc.label = lilv_node_as_string(label);
1373 if (def && lilv_node_is_float(def)) {
1374 desc.normal = lilv_node_as_float(def);
1376 if (minimum && lilv_node_is_float(minimum)) {
1377 desc.lower = lilv_node_as_float(minimum);
1379 if (maximum && lilv_node_is_float(maximum)) {
1380 desc.upper = lilv_node_as_float(maximum);
1382 load_parameter_descriptor_units(lworld, desc, units);
1383 desc.datatype = datatype;
1384 desc.toggled |= datatype == Variant::BOOL;
1385 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1386 desc.update_steps();
1388 lilv_nodes_free(units);
1389 lilv_node_free(label);
1390 lilv_node_free(def);
1391 lilv_node_free(minimum);
1392 lilv_node_free(maximum);
1396 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1398 LilvWorld* lworld = _world.world;
1399 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1400 LilvNodes* properties = lilv_world_find_nodes(
1401 lworld, subject, _world.patch_writable, NULL);
1402 LILV_FOREACH(nodes, p, properties) {
1403 // Get label and range
1404 const LilvNode* prop = lilv_nodes_get(properties, p);
1405 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1407 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1408 lilv_node_as_uri(prop)) << endmsg;
1412 // Convert range to variant type (TODO: support for multiple range types)
1413 Variant::Type datatype;
1414 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1415 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1416 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1420 // Add description to result
1421 ParameterDescriptor desc;
1422 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1423 desc.datatype = datatype;
1424 load_parameter_descriptor(_world, desc, datatype, prop);
1425 descs.insert(std::make_pair(desc.key, desc));
1427 lilv_node_free(range);
1429 lilv_nodes_free(properties);
1433 LV2Plugin::announce_property_values()
1435 if (_patch_port_in_index == (uint32_t)-1) {
1439 // Set up forge to write to temporary buffer on the stack
1440 LV2_Atom_Forge* forge = &_impl->ui_forge;
1441 LV2_Atom_Forge_Frame frame;
1442 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1444 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1446 // Serialize patch:Get message with no subject (implicitly plugin instance)
1447 #ifdef HAVE_LV2_1_10_0
1448 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1450 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1453 // Write message to UI=>Plugin ring
1454 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1455 write_from_ui(_patch_port_in_index,
1456 _uri_map.urids.atom_eventTransfer,
1457 lv2_atom_total_size(atom),
1458 (const uint8_t*)atom);
1462 LV2Plugin::enable_ui_emission()
1465 /* see note in LV2Plugin::write_from_ui() */
1466 uint32_t bufsiz = 32768;
1467 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1468 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1470 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1471 rbs = max((size_t) bufsiz * 8, rbs);
1472 _to_ui = new RingBuffer<uint8_t>(rbs);
1477 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1483 uint32_t read_space = _to_ui->read_space();
1484 while (read_space > sizeof(UIMessage)) {
1486 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1487 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1490 vector<uint8_t> body(msg.size);
1491 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1492 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1496 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1498 read_space -= sizeof(msg) + msg.size;
1503 LV2Plugin::work(uint32_t size, const void* data)
1505 return _impl->work_iface->work(
1506 _impl->instance->lv2_handle, work_respond, this, size, data);
1510 LV2Plugin::work_response(uint32_t size, const void* data)
1512 return _impl->work_iface->work_response(
1513 _impl->instance->lv2_handle, size, data);
1517 LV2Plugin::set_insert_id(PBD::ID id)
1523 LV2Plugin::set_state(const XMLNode& node, int version)
1526 const XMLProperty* prop;
1527 XMLNodeConstIterator iter;
1532 LocaleGuard lg(X_("C"));
1534 if (node.name() != state_node_name()) {
1535 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1539 #ifndef NO_PLUGIN_STATE
1541 if (version < 3000) {
1542 nodes = node.children("port");
1544 nodes = node.children("Port");
1547 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1551 if ((prop = child->property("symbol")) != 0) {
1552 sym = prop->value().c_str();
1554 warning << _("LV2: port has no symbol, ignored") << endmsg;
1558 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1560 if (i != _port_indices.end()) {
1561 port_id = i->second;
1563 warning << _("LV2: port has unknown index, ignored") << endmsg;
1567 if ((prop = child->property("value")) != 0) {
1568 value = prop->value().c_str();
1570 warning << _("LV2: port has no value, ignored") << endmsg;
1574 set_parameter(port_id, atof(value));
1578 if ((prop = node.property("state-dir")) != 0) {
1579 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1580 error << string_compose(
1581 "LV2: failed to parse state version from \"%1\"",
1582 prop->value()) << endmsg;
1585 std::string state_file = Glib::build_filename(
1587 Glib::build_filename(prop->value(), "state.ttl"));
1589 LilvState* state = lilv_state_new_from_file(
1590 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1592 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1595 latency_compute_run();
1598 return Plugin::set_state(node, version);
1602 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1604 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1606 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1611 LilvNodes* portunits;
1612 LilvNode *def, *min, *max;
1613 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1614 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1616 // TODO: Once we can rely on lilv 0.18.0 being present,
1617 // load_parameter_descriptor() can be used for ports as well
1618 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1619 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1620 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1621 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1622 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1623 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1624 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1625 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1626 load_parameter_descriptor_units(_world.world, desc, portunits);
1628 if (desc.sr_dependent) {
1629 desc.lower *= _session.frame_rate ();
1630 desc.upper *= _session.frame_rate ();
1633 desc.min_unbound = false; // TODO: LV2 extension required
1634 desc.max_unbound = false; // TODO: LV2 extension required
1636 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1637 desc.scale_points = get_scale_points(which);
1639 desc.update_steps();
1641 lilv_node_free(def);
1642 lilv_node_free(min);
1643 lilv_node_free(max);
1644 lilv_nodes_free(portunits);
1650 LV2Plugin::describe_parameter(Evoral::Parameter which)
1652 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1654 if (lilv_port_has_property(_impl->plugin,
1655 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1656 return X_("hidden");
1659 if (lilv_port_has_property(_impl->plugin,
1660 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1661 return X_("hidden");
1664 if (lilv_port_has_property(_impl->plugin,
1665 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1666 return X_("latency");
1669 LilvNode* name = lilv_port_get_name(_impl->plugin,
1670 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1671 string ret(lilv_node_as_string(name));
1672 lilv_node_free(name);
1680 LV2Plugin::signal_latency() const
1682 if (_latency_control_port) {
1683 return (framecnt_t)floor(*_latency_control_port);
1689 set<Evoral::Parameter>
1690 LV2Plugin::automatable() const
1692 set<Evoral::Parameter> ret;
1694 for (uint32_t i = 0; i < parameter_count(); ++i) {
1695 if (parameter_is_input(i) && parameter_is_control(i)) {
1696 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1700 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1701 p != _property_descriptors.end();
1703 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1709 LV2Plugin::activate()
1711 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1713 if (!_was_activated) {
1714 lilv_instance_activate(_impl->instance);
1715 _was_activated = true;
1720 LV2Plugin::deactivate()
1722 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1724 if (_was_activated) {
1725 lilv_instance_deactivate(_impl->instance);
1726 _was_activated = false;
1731 LV2Plugin::cleanup()
1733 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1737 lilv_instance_free(_impl->instance);
1738 _impl->instance = NULL;
1742 LV2Plugin::allocate_atom_event_buffers()
1744 /* reserve local scratch buffers for ATOM event-queues */
1745 const LilvPlugin* p = _impl->plugin;
1747 /* count non-MIDI atom event-ports
1748 * TODO: nicely ask drobilla to make a lilv_ call for that
1750 int count_atom_out = 0;
1751 int count_atom_in = 0;
1752 int minimumSize = 32768; // TODO use a per-port minimum-size
1753 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1754 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1755 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1756 LilvNodes* buffer_types = lilv_port_get_value(
1757 p, port, _world.atom_bufferType);
1758 LilvNodes* atom_supports = lilv_port_get_value(
1759 p, port, _world.atom_supports);
1761 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1762 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1763 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1766 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1769 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1770 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1771 if (min_size && lilv_node_is_int(min_size)) {
1772 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1774 lilv_nodes_free(min_size_v);
1776 lilv_nodes_free(buffer_types);
1777 lilv_nodes_free(atom_supports);
1781 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1782 name(), count_atom_in, count_atom_out));
1784 const int total_atom_buffers = (count_atom_in + count_atom_out);
1785 if (_atom_ev_buffers || total_atom_buffers == 0) {
1789 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1790 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1791 for (int i = 0; i < total_atom_buffers; ++i ) {
1792 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1793 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1795 _atom_ev_buffers[total_atom_buffers] = 0;
1799 /** Write an ardour position/time/tempo/meter as an LV2 event.
1800 * @return true on success.
1803 write_position(LV2_Atom_Forge* forge,
1805 const TempoMetric& t,
1806 Timecode::BBT_Time& bbt,
1808 framepos_t position,
1811 const URIMap::URIDs& urids = URIMap::instance().urids;
1813 uint8_t pos_buf[256];
1814 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1815 LV2_Atom_Forge_Frame frame;
1816 #ifdef HAVE_LV2_1_10_0
1817 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1818 lv2_atom_forge_key(forge, urids.time_frame);
1819 lv2_atom_forge_long(forge, position);
1820 lv2_atom_forge_key(forge, urids.time_speed);
1821 lv2_atom_forge_float(forge, speed);
1822 lv2_atom_forge_key(forge, urids.time_barBeat);
1823 lv2_atom_forge_float(forge, bbt.beats - 1 +
1824 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1825 lv2_atom_forge_key(forge, urids.time_bar);
1826 lv2_atom_forge_long(forge, bbt.bars - 1);
1827 lv2_atom_forge_key(forge, urids.time_beatUnit);
1828 lv2_atom_forge_int(forge, t.meter().note_divisor());
1829 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1830 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1831 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1832 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1834 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1835 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1836 lv2_atom_forge_long(forge, position);
1837 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1838 lv2_atom_forge_float(forge, speed);
1839 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1840 lv2_atom_forge_float(forge, bbt.beats - 1 +
1841 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1842 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1843 lv2_atom_forge_long(forge, bbt.bars - 1);
1844 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1845 lv2_atom_forge_int(forge, t.meter().note_divisor());
1846 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1847 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1848 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1849 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1852 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
1853 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1854 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1855 (const uint8_t*)(atom + 1));
1859 LV2Plugin::connect_and_run(BufferSet& bufs,
1860 ChanMapping in_map, ChanMapping out_map,
1861 pframes_t nframes, framecnt_t offset)
1863 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1864 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1866 cycles_t then = get_cycles();
1868 TempoMap& tmap = _session.tempo_map();
1869 Metrics::const_iterator metric_i = tmap.metrics_end();
1870 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
1872 if (_freewheel_control_port) {
1873 *_freewheel_control_port = _session.engine().freewheeling();
1876 if (_bpm_control_port) {
1877 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1880 ChanCount bufs_count;
1881 bufs_count.set(DataType::AUDIO, 1);
1882 bufs_count.set(DataType::MIDI, 1);
1883 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
1884 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1885 uint32_t const num_ports = parameter_count();
1886 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1888 uint32_t audio_in_index = 0;
1889 uint32_t audio_out_index = 0;
1890 uint32_t midi_in_index = 0;
1891 uint32_t midi_out_index = 0;
1892 uint32_t atom_port_index = 0;
1893 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1895 uint32_t index = nil_index;
1896 PortFlags flags = _port_flags[port_index];
1898 if (flags & PORT_AUDIO) {
1899 if (flags & PORT_INPUT) {
1900 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1902 ? bufs.get_audio(index).data(offset)
1903 : silent_bufs.get_audio(0).data(offset);
1905 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1907 ? bufs.get_audio(index).data(offset)
1908 : scratch_bufs.get_audio(0).data(offset);
1910 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1911 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1912 be necessary, but the mapping is illegal in some cases. Ideally
1913 that should be fixed, but this is easier...
1915 if (flags & PORT_MIDI) {
1916 if (flags & PORT_INPUT) {
1917 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1919 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1921 if (valid && bufs.count().n_midi() > index) {
1922 /* Note, ensure_lv2_bufsize() is not RT safe!
1923 * However free()/alloc() is only called if a
1924 * plugin requires a rsz:minimumSize buffersize
1925 * and the existing buffer if smaller.
1927 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1928 _ev_buffers[port_index] = bufs.get_lv2_midi(
1929 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1931 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1932 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1933 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1937 if (valid && (flags & PORT_INPUT)) {
1938 Timecode::BBT_Time bbt;
1939 if ((flags & PORT_POSITION)) {
1940 if (_session.transport_frame() != _next_cycle_start ||
1941 _session.transport_speed() != _next_cycle_speed) {
1942 // Transport has changed, write position at cycle start
1943 tmap.bbt_time(_session.transport_frame(), bbt);
1944 write_position(&_impl->forge, _ev_buffers[port_index],
1945 tmetric, bbt, _session.transport_speed(),
1946 _session.transport_frame(), 0);
1950 // Get MIDI iterator range (empty range if no MIDI)
1951 MidiBuffer::iterator m = (index != nil_index)
1952 ? bufs.get_midi(index).begin()
1953 : silent_bufs.get_midi(0).end();
1954 MidiBuffer::iterator m_end = (index != nil_index)
1955 ? bufs.get_midi(index).end()
1958 // Now merge MIDI and any transport events into the buffer
1959 const uint32_t type = _uri_map.urids.midi_MidiEvent;
1960 const framepos_t tend = _session.transport_frame() + nframes;
1962 while (m != m_end || (metric_i != tmap.metrics_end() &&
1963 (*metric_i)->frame() < tend)) {
1964 MetricSection* metric = (metric_i != tmap.metrics_end())
1966 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1967 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1968 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1969 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1972 tmetric.set_metric(metric);
1973 bbt = metric->start();
1974 write_position(&_impl->forge, _ev_buffers[port_index],
1975 tmetric, bbt, _session.transport_speed(),
1977 metric->frame() - _session.transport_frame());
1981 } else if (!valid) {
1982 // Nothing we understand or care about, connect to scratch
1983 // see note for midi-buffer size above
1984 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
1985 0, _port_minimumSize[port_index]);
1986 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
1987 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
1990 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
1992 continue; // Control port, leave buffer alone
1994 lilv_instance_connect_port(_impl->instance, port_index, buf);
1997 // Read messages from UI and push into appropriate buffers
1999 uint32_t read_space = _from_ui->read_space();
2000 while (read_space > sizeof(UIMessage)) {
2002 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2003 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2006 vector<uint8_t> body(msg.size);
2007 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2008 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2011 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2012 LV2_Evbuf* buf = _ev_buffers[msg.index];
2013 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2014 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2015 if (!lv2_evbuf_write(&i, nframes, 0, atom->type, atom->size,
2016 (const uint8_t*)(atom + 1))) {
2017 error << "Failed to write data to LV2 event buffer\n";
2020 error << "Received unknown message type from UI" << endmsg;
2022 read_space -= sizeof(UIMessage) + msg.size;
2029 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2030 PortFlags flags = _port_flags[port_index];
2033 /* TODO ask drobilla about comment
2034 * "Make Ardour event buffers generic so plugins can communicate"
2035 * in libs/ardour/buffer_set.cc:310
2037 * ideally the user could choose which of the following two modes
2038 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2040 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2041 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2042 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2043 * for quite a while at least ;)
2045 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2046 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2047 const uint32_t buf_index = out_map.get(
2048 DataType::MIDI, midi_out_index++, &valid);
2050 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2053 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2054 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2055 const uint32_t buf_index = out_map.get(
2056 DataType::MIDI, midi_out_index++, &valid);
2058 bufs.flush_lv2_midi(true, buf_index);
2063 // Write messages to UI
2064 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2065 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2066 LV2_Evbuf* buf = _ev_buffers[port_index];
2067 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2068 lv2_evbuf_is_valid(i);
2069 i = lv2_evbuf_next(i)) {
2070 uint32_t frames, subframes, type, size;
2072 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2074 // Intercept patch change messages to emit PropertyChanged signal
2075 if ((flags & PORT_PATCHMSG)) {
2076 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2077 if (atom->type == _uri_map.urids.atom_Blank ||
2078 atom->type == _uri_map.urids.atom_Object) {
2079 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2080 if (obj->body.otype == _uri_map.urids.patch_Set) {
2081 const LV2_Atom* property = NULL;
2082 const LV2_Atom* value = NULL;
2083 lv2_atom_object_get(obj,
2084 _uri_map.urids.patch_property, &property,
2085 _uri_map.urids.patch_value, &value,
2088 if (!property || !value ||
2089 property->type != _uri_map.urids.atom_URID ||
2090 value->type != _uri_map.urids.atom_Path) {
2091 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2095 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2096 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2098 // Emit PropertyChanged signal for UI
2099 // TODO: This should emit the control's Changed signal
2100 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2105 if (!_to_ui) continue;
2106 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2107 size + sizeof(LV2_Atom),
2108 data - sizeof(LV2_Atom));
2113 cycles_t now = get_cycles();
2114 set_cycles((uint32_t)(now - then));
2116 // Update expected transport information for next cycle so we can detect changes
2117 _next_cycle_speed = _session.transport_speed();
2118 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2124 LV2Plugin::parameter_is_control(uint32_t param) const
2126 assert(param < _port_flags.size());
2127 return _port_flags[param] & PORT_CONTROL;
2131 LV2Plugin::parameter_is_audio(uint32_t param) const
2133 assert(param < _port_flags.size());
2134 return _port_flags[param] & PORT_AUDIO;
2138 LV2Plugin::parameter_is_event(uint32_t param) const
2140 assert(param < _port_flags.size());
2141 return _port_flags[param] & PORT_EVENT;
2145 LV2Plugin::parameter_is_output(uint32_t param) const
2147 assert(param < _port_flags.size());
2148 return _port_flags[param] & PORT_OUTPUT;
2152 LV2Plugin::parameter_is_input(uint32_t param) const
2154 assert(param < _port_flags.size());
2155 return _port_flags[param] & PORT_INPUT;
2159 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2162 if (param < parameter_count()) {
2163 snprintf(buf, len, "%.3f", get_parameter(param));
2170 boost::shared_ptr<ScalePoints>
2171 LV2Plugin::get_scale_points(uint32_t port_index) const
2173 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2174 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2176 boost::shared_ptr<ScalePoints> ret;
2181 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2183 LILV_FOREACH(scale_points, i, points) {
2184 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2185 const LilvNode* label = lilv_scale_point_get_label(p);
2186 const LilvNode* value = lilv_scale_point_get_value(p);
2187 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2188 ret->insert(make_pair(lilv_node_as_string(label),
2189 lilv_node_as_float(value)));
2193 lilv_scale_points_free(points);
2198 LV2Plugin::run(pframes_t nframes)
2200 uint32_t const N = parameter_count();
2201 for (uint32_t i = 0; i < N; ++i) {
2202 if (parameter_is_control(i) && parameter_is_input(i)) {
2203 _control_data[i] = _shadow_data[i];
2207 lilv_instance_run(_impl->instance, nframes);
2209 if (_impl->work_iface) {
2210 _worker->emit_responses();
2211 if (_impl->work_iface->end_run) {
2212 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2218 LV2Plugin::latency_compute_run()
2220 if (!_latency_control_port) {
2224 // Run the plugin so that it can set its latency parameter
2226 bool was_activated = _was_activated;
2229 uint32_t port_index = 0;
2230 uint32_t in_index = 0;
2231 uint32_t out_index = 0;
2233 // this is done in the main thread. non realtime.
2234 const framecnt_t bufsize = _engine.samples_per_cycle();
2235 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2237 memset(buffer, 0, sizeof(float) * bufsize);
2239 // FIXME: Ensure plugins can handle in-place processing
2243 while (port_index < parameter_count()) {
2244 if (parameter_is_audio(port_index)) {
2245 if (parameter_is_input(port_index)) {
2246 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2248 } else if (parameter_is_output(port_index)) {
2249 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2258 if (was_activated) {
2265 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2267 const LilvPort* port = NULL;
2268 LilvNode* designation = lilv_new_uri(_world.world, uri);
2269 port = lilv_plugin_get_port_by_designation(
2270 plugin, _world.lv2_InputPort, designation);
2271 lilv_node_free(designation);
2273 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2278 static bool lv2_filter (const string& str, void* /*arg*/)
2280 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2282 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2286 LV2World::LV2World()
2287 : world(lilv_world_new())
2288 , _bundle_checked(false)
2290 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2291 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2292 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2293 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2294 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2295 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2296 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2297 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2298 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2299 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2300 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2301 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2302 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2303 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2304 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2305 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2306 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2307 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2308 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2309 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2310 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2311 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2312 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2313 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2314 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2315 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2316 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2317 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2318 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2319 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2320 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2321 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2322 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2323 units_render = lilv_new_uri(world, LV2_UNITS__render);
2324 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2325 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2326 units_db = lilv_new_uri(world, LV2_UNITS__db);
2327 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2328 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2331 LV2World::~LV2World()
2333 lilv_node_free(patch_Message);
2334 lilv_node_free(patch_writable);
2335 lilv_node_free(units_hz);
2336 lilv_node_free(units_midiNote);
2337 lilv_node_free(units_db);
2338 lilv_node_free(units_unit);
2339 lilv_node_free(units_render);
2340 lilv_node_free(ui_externalkx);
2341 lilv_node_free(ui_external);
2342 lilv_node_free(ui_GtkUI);
2343 lilv_node_free(time_Position);
2344 lilv_node_free(rsz_minimumSize);
2345 lilv_node_free(rdfs_comment);
2346 lilv_node_free(rdfs_label);
2347 lilv_node_free(rdfs_range);
2348 lilv_node_free(midi_MidiEvent);
2349 lilv_node_free(lv2_enumeration);
2350 lilv_node_free(lv2_freewheeling);
2351 lilv_node_free(lv2_toggled);
2352 lilv_node_free(lv2_sampleRate);
2353 lilv_node_free(lv2_reportsLatency);
2354 lilv_node_free(lv2_integer);
2355 lilv_node_free(lv2_inPlaceBroken);
2356 lilv_node_free(lv2_OutputPort);
2357 lilv_node_free(lv2_InputPort);
2358 lilv_node_free(lv2_ControlPort);
2359 lilv_node_free(lv2_AudioPort);
2360 lilv_node_free(ext_notOnGUI);
2361 lilv_node_free(ext_logarithmic);
2362 lilv_node_free(ev_EventPort);
2363 lilv_node_free(atom_supports);
2364 lilv_node_free(atom_eventTransfer);
2365 lilv_node_free(atom_bufferType);
2366 lilv_node_free(atom_Sequence);
2367 lilv_node_free(atom_Chunk);
2368 lilv_node_free(atom_AtomPort);
2369 lilv_world_free(world);
2373 LV2World::load_bundled_plugins(bool verbose)
2375 if (!_bundle_checked) {
2377 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2380 vector<string> plugin_objects;
2381 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2382 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2383 #ifdef PLATFORM_WINDOWS
2384 string uri = "file:///" + *x + "/";
2386 string uri = "file://" + *x + "/";
2388 LilvNode *node = lilv_new_uri(world, uri.c_str());
2389 lilv_world_load_bundle(world, node);
2390 lilv_node_free(node);
2393 lilv_world_load_all(world);
2394 _bundle_checked = true;
2398 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2401 _plugin_uri = strdup(plugin_uri);
2404 LV2PluginInfo::~LV2PluginInfo()
2411 LV2PluginInfo::load(Session& session)
2415 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2416 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2417 if (!uri) { throw failed_constructor(); }
2418 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2419 if (!lp) { throw failed_constructor(); }
2420 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2421 lilv_node_free(uri);
2422 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2424 } catch (failed_constructor& err) {
2425 return PluginPtr((Plugin*)0);
2432 LV2PluginInfo::discover()
2435 world.load_bundled_plugins();
2436 _world.load_bundled_plugins(true);
2438 PluginInfoList* plugs = new PluginInfoList;
2439 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2441 LILV_FOREACH(plugins, i, plugins) {
2442 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2443 const LilvNode* pun = lilv_plugin_get_uri(p);
2445 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2447 LilvNode* name = lilv_plugin_get_name(p);
2448 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2449 warning << "Ignoring invalid LV2 plugin "
2450 << lilv_node_as_string(lilv_plugin_get_uri(p))
2457 info->name = string(lilv_node_as_string(name));
2458 lilv_node_free(name);
2459 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2461 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2462 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2463 info->category = lilv_node_as_string(label);
2465 LilvNode* author_name = lilv_plugin_get_author_name(p);
2466 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2467 lilv_node_free(author_name);
2469 info->path = "/NOPATH"; // Meaningless for LV2
2471 /* count atom-event-ports that feature
2472 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2474 * TODO: nicely ask drobilla to make a lilv_ call for that
2476 int count_midi_out = 0;
2477 int count_midi_in = 0;
2478 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2479 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2480 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2481 LilvNodes* buffer_types = lilv_port_get_value(
2482 p, port, world.atom_bufferType);
2483 LilvNodes* atom_supports = lilv_port_get_value(
2484 p, port, world.atom_supports);
2486 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2487 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2488 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2491 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2495 lilv_nodes_free(buffer_types);
2496 lilv_nodes_free(atom_supports);
2500 info->n_inputs.set_audio(
2501 lilv_plugin_get_num_ports_of_class(
2502 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2503 info->n_inputs.set_midi(
2504 lilv_plugin_get_num_ports_of_class(
2505 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2508 info->n_outputs.set_audio(
2509 lilv_plugin_get_num_ports_of_class(
2510 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2511 info->n_outputs.set_midi(
2512 lilv_plugin_get_num_ports_of_class(
2513 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2516 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2517 info->index = 0; // Meaningless for LV2
2519 plugs->push_back(info);