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 LilvNode* plug_name = lilv_plugin_get_name(_impl->plugin);
1078 const string prefix = legalize_for_uri(lilv_node_as_string(plug_name));
1079 const string base_name = legalize_for_uri(name);
1080 const string file_name = base_name + ".ttl";
1081 const string bundle = Glib::build_filename(
1082 Glib::get_home_dir(),
1083 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1085 #ifdef HAVE_LILV_0_21_3
1086 /* delete reference to old preset (if any) */
1087 const PresetRecord* r = preset_by_label(name);
1089 LilvNode* pset = lilv_new_uri (_world.world, r->uri.c_str());
1091 lilv_world_unload_resource (_world.world, pset);
1092 lilv_node_free(pset);
1097 LilvState* state = lilv_state_new_from_instance(
1100 _uri_map.urid_map(),
1101 scratch_dir().c_str(), // file_dir
1102 bundle.c_str(), // copy_dir
1103 bundle.c_str(), // link_dir
1104 bundle.c_str(), // save_dir
1105 lv2plugin_get_port_value, // get_value
1106 (void*)this, // user_data
1107 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1108 _features // features
1111 lilv_state_set_label(state, name.c_str());
1113 _world.world, // world
1114 _uri_map.urid_map(), // map
1115 _uri_map.urid_unmap(), // unmap
1117 NULL, // uri (NULL = use file URI)
1118 bundle.c_str(), // dir
1119 file_name.c_str() // filename
1122 lilv_state_free(state);
1124 std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1125 LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1126 LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1127 #ifdef HAVE_LILV_0_21_3
1128 lilv_world_unload_resource(_world.world, node_preset);
1129 lilv_world_unload_bundle(_world.world, node_bundle);
1131 lilv_world_load_bundle(_world.world, node_bundle);
1132 lilv_world_load_resource(_world.world, node_preset);
1133 lilv_node_free(node_bundle);
1134 lilv_node_free(node_preset);
1135 lilv_node_free(plug_name);
1140 LV2Plugin::do_remove_preset(string name)
1142 #ifdef HAVE_LILV_0_21_3
1143 /* Look up preset record by label (FIXME: ick, label as ID) */
1144 const PresetRecord* r = preset_by_label(name);
1149 /* Load a LilvState for the preset. */
1150 LilvWorld* world = _world.world;
1151 LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1152 LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1154 lilv_node_free(pset);
1158 /* Unload preset from world. */
1159 lilv_world_unload_resource(world, pset);
1161 /* Delete it from the file system. This will remove the preset file and the entry
1162 from the manifest. If this results in an empty manifest (i.e. the
1163 preset is the only thing in the bundle), then the bundle is removed. */
1164 lilv_state_delete(world, state);
1166 lilv_state_free(state);
1167 lilv_node_free(pset);
1169 /* Without lilv_state_delete(), we could delete the preset file, but this
1170 would leave a broken bundle/manifest around, so the preset would still
1171 be visible, but broken. Naively deleting a bundle is too dangerous, so
1172 we simply do not support preset deletion with older Lilv */
1176 LV2Plugin::has_editor() const
1178 return _impl->ui != NULL;
1182 LV2Plugin::has_message_output() const
1184 for (uint32_t i = 0; i < num_ports(); ++i) {
1185 if ((_port_flags[i] & PORT_SEQUENCE) &&
1186 (_port_flags[i] & PORT_OUTPUT)) {
1194 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1198 const uint8_t* body)
1200 const uint32_t buf_size = sizeof(UIMessage) + size;
1201 vector<uint8_t> buf(buf_size);
1203 UIMessage* msg = (UIMessage*)&buf[0];
1205 msg->protocol = protocol;
1207 memcpy(msg + 1, body, size);
1209 return (dest->write(&buf[0], buf_size) == buf_size);
1213 LV2Plugin::write_from_ui(uint32_t index,
1216 const uint8_t* body)
1219 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1220 /* buffer data communication from plugin UI to plugin instance.
1221 * this buffer needs to potentially hold
1222 * (port's minimumSize) * (audio-periods) / (UI-periods)
1225 * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1226 * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1227 * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1229 * it is NOT safe to overflow (msg.size will be misinterpreted)
1231 uint32_t bufsiz = 32768;
1232 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1233 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1235 rbs = max((size_t) bufsiz * 8, rbs);
1236 _from_ui = new RingBuffer<uint8_t>(rbs);
1239 if (!write_to(_from_ui, index, protocol, size, body)) {
1240 error << "Error writing from UI to plugin" << endmsg;
1247 LV2Plugin::write_to_ui(uint32_t index,
1250 const uint8_t* body)
1252 if (!write_to(_to_ui, index, protocol, size, body)) {
1253 error << "Error writing from plugin to UI" << endmsg;
1260 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1262 switch (value.type()) {
1263 case Variant::NOTHING:
1265 case Variant::BEATS:
1266 // No atom type for this, just forge a double
1267 lv2_atom_forge_double(forge, value.get_beats().to_double());
1270 lv2_atom_forge_bool(forge, value.get_bool());
1272 case Variant::DOUBLE:
1273 lv2_atom_forge_double(forge, value.get_double());
1275 case Variant::FLOAT:
1276 lv2_atom_forge_float(forge, value.get_float());
1279 lv2_atom_forge_int(forge, value.get_int());
1282 lv2_atom_forge_long(forge, value.get_long());
1285 lv2_atom_forge_path(
1286 forge, value.get_path().c_str(), value.get_path().size());
1288 case Variant::STRING:
1289 lv2_atom_forge_string(
1290 forge, value.get_string().c_str(), value.get_string().size());
1294 forge, value.get_uri().c_str(), value.get_uri().size());
1299 /** Get a variant type from a URI, return false iff no match found. */
1301 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1303 if (uri == LV2_ATOM__Bool) {
1304 type = Variant::BOOL;
1305 } else if (uri == LV2_ATOM__Double) {
1306 type = Variant::DOUBLE;
1307 } else if (uri == LV2_ATOM__Float) {
1308 type = Variant::FLOAT;
1309 } else if (uri == LV2_ATOM__Int) {
1310 type = Variant::INT;
1311 } else if (uri == LV2_ATOM__Long) {
1312 type = Variant::LONG;
1313 } else if (uri == LV2_ATOM__Path) {
1314 type = Variant::PATH;
1315 } else if (uri == LV2_ATOM__String) {
1316 type = Variant::STRING;
1317 } else if (uri == LV2_ATOM__URI) {
1318 type = Variant::URI;
1326 LV2Plugin::set_property(uint32_t key, const Variant& value)
1328 if (_patch_port_in_index == (uint32_t)-1) {
1329 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1331 } else if (value.type() == Variant::NOTHING) {
1332 error << "LV2: set_property called with void value" << endmsg;
1336 // Set up forge to write to temporary buffer on the stack
1337 LV2_Atom_Forge* forge = &_impl->ui_forge;
1338 LV2_Atom_Forge_Frame frame;
1339 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1341 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1343 // Serialize patch:Set message to set property
1344 #ifdef HAVE_LV2_1_10_0
1345 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1346 lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1347 lv2_atom_forge_urid(forge, key);
1348 lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1350 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1351 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1352 lv2_atom_forge_urid(forge, key);
1353 lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1356 forge_variant(forge, value);
1358 // Write message to UI=>Plugin ring
1359 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1360 write_from_ui(_patch_port_in_index,
1361 _uri_map.urids.atom_eventTransfer,
1362 lv2_atom_total_size(atom),
1363 (const uint8_t*)atom);
1366 const ParameterDescriptor&
1367 LV2Plugin::get_property_descriptor(uint32_t id) const
1369 PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1370 if (p != _property_descriptors.end()) {
1373 return Plugin::get_property_descriptor(id);
1377 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1379 if (lilv_nodes_contains(units, _world.units_midiNote)) {
1380 desc.unit = ParameterDescriptor::MIDI_NOTE;
1381 } else if (lilv_nodes_contains(units, _world.units_db)) {
1382 desc.unit = ParameterDescriptor::DB;
1383 } else if (lilv_nodes_contains(units, _world.units_hz)) {
1384 desc.unit = ParameterDescriptor::HZ;
1386 if (lilv_nodes_size(units) > 0) {
1387 const LilvNode* unit = lilv_nodes_get_first(units);
1388 LilvNode* render = get_value(lworld, unit, _world.units_render);
1390 desc.print_fmt = lilv_node_as_string(render);
1391 lilv_node_free(render);
1397 load_parameter_descriptor(LV2World& world,
1398 ParameterDescriptor& desc,
1399 Variant::Type datatype,
1400 const LilvNode* subject)
1402 LilvWorld* lworld = _world.world;
1403 LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1404 LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1405 LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1406 LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1407 LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1409 desc.label = lilv_node_as_string(label);
1411 if (def && lilv_node_is_float(def)) {
1412 desc.normal = lilv_node_as_float(def);
1414 if (minimum && lilv_node_is_float(minimum)) {
1415 desc.lower = lilv_node_as_float(minimum);
1417 if (maximum && lilv_node_is_float(maximum)) {
1418 desc.upper = lilv_node_as_float(maximum);
1420 load_parameter_descriptor_units(lworld, desc, units);
1421 desc.datatype = datatype;
1422 desc.toggled |= datatype == Variant::BOOL;
1423 desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1424 desc.update_steps();
1426 lilv_nodes_free(units);
1427 lilv_node_free(label);
1428 lilv_node_free(def);
1429 lilv_node_free(minimum);
1430 lilv_node_free(maximum);
1434 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1436 LilvWorld* lworld = _world.world;
1437 const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1438 LilvNodes* properties = lilv_world_find_nodes(
1439 lworld, subject, _world.patch_writable, NULL);
1440 LILV_FOREACH(nodes, p, properties) {
1441 // Get label and range
1442 const LilvNode* prop = lilv_nodes_get(properties, p);
1443 LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1445 warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1446 lilv_node_as_uri(prop)) << endmsg;
1450 // Convert range to variant type (TODO: support for multiple range types)
1451 Variant::Type datatype;
1452 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1453 error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1454 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1458 // Add description to result
1459 ParameterDescriptor desc;
1460 desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1461 desc.datatype = datatype;
1462 load_parameter_descriptor(_world, desc, datatype, prop);
1463 descs.insert(std::make_pair(desc.key, desc));
1465 lilv_node_free(range);
1467 lilv_nodes_free(properties);
1471 LV2Plugin::announce_property_values()
1473 if (_patch_port_in_index == (uint32_t)-1) {
1477 // Set up forge to write to temporary buffer on the stack
1478 LV2_Atom_Forge* forge = &_impl->ui_forge;
1479 LV2_Atom_Forge_Frame frame;
1480 uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1482 lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1484 // Serialize patch:Get message with no subject (implicitly plugin instance)
1485 #ifdef HAVE_LV2_1_10_0
1486 lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1488 lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1491 // Write message to UI=>Plugin ring
1492 const LV2_Atom* const atom = (const LV2_Atom*)buf;
1493 write_from_ui(_patch_port_in_index,
1494 _uri_map.urids.atom_eventTransfer,
1495 lv2_atom_total_size(atom),
1496 (const uint8_t*)atom);
1500 LV2Plugin::enable_ui_emission()
1503 /* see note in LV2Plugin::write_from_ui() */
1504 uint32_t bufsiz = 32768;
1505 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1506 bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1508 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1509 rbs = max((size_t) bufsiz * 8, rbs);
1510 _to_ui = new RingBuffer<uint8_t>(rbs);
1515 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1521 uint32_t read_space = _to_ui->read_space();
1522 while (read_space > sizeof(UIMessage)) {
1524 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1525 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1528 vector<uint8_t> body(msg.size);
1529 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1530 error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1534 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1536 read_space -= sizeof(msg) + msg.size;
1541 LV2Plugin::work(uint32_t size, const void* data)
1543 return _impl->work_iface->work(
1544 _impl->instance->lv2_handle, work_respond, this, size, data);
1548 LV2Plugin::work_response(uint32_t size, const void* data)
1550 return _impl->work_iface->work_response(
1551 _impl->instance->lv2_handle, size, data);
1555 LV2Plugin::set_insert_id(PBD::ID id)
1561 LV2Plugin::set_state(const XMLNode& node, int version)
1564 const XMLProperty* prop;
1565 XMLNodeConstIterator iter;
1570 LocaleGuard lg(X_("C"));
1572 if (node.name() != state_node_name()) {
1573 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1577 #ifndef NO_PLUGIN_STATE
1579 if (version < 3000) {
1580 nodes = node.children("port");
1582 nodes = node.children("Port");
1585 for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1589 if ((prop = child->property("symbol")) != 0) {
1590 sym = prop->value().c_str();
1592 warning << _("LV2: port has no symbol, ignored") << endmsg;
1596 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1598 if (i != _port_indices.end()) {
1599 port_id = i->second;
1601 warning << _("LV2: port has unknown index, ignored") << endmsg;
1605 if ((prop = child->property("value")) != 0) {
1606 value = prop->value().c_str();
1608 warning << _("LV2: port has no value, ignored") << endmsg;
1612 set_parameter(port_id, atof(value));
1616 if ((prop = node.property("state-dir")) != 0) {
1617 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1618 error << string_compose(
1619 "LV2: failed to parse state version from \"%1\"",
1620 prop->value()) << endmsg;
1623 std::string state_file = Glib::build_filename(
1625 Glib::build_filename(prop->value(), "state.ttl"));
1627 if (!Glib::file_test (state_file, Glib::FileTest (Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_REGULAR))) {
1628 /* this should be done in lilv_state_new_from_file()
1629 * some systems don't like realpath() calls with an non-existent file.
1630 * (hopefully this fixes crashes on OSX 10.5/PPC, see #6456,
1631 * segfault in __asm realpath$DARWIN_EXTSN
1632 * if so, backport upstream to liblilv)
1634 error << string_compose(
1635 "LV2: expected state file \"%1\" does not exist.",
1636 state_file) << endmsg;
1639 LilvState* state = lilv_state_new_from_file(
1640 _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1642 // lilv_state_restore allows/ignores possible NULL state
1643 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1647 latency_compute_run();
1650 return Plugin::set_state(node, version);
1654 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1656 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1658 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1663 LilvNodes* portunits;
1664 LilvNode *def, *min, *max;
1665 lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1666 portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1668 // TODO: Once we can rely on lilv 0.18.0 being present,
1669 // load_parameter_descriptor() can be used for ports as well
1670 desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1671 desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1672 desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1673 desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1674 desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1675 desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1676 desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1677 desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1678 load_parameter_descriptor_units(_world.world, desc, portunits);
1680 if (desc.sr_dependent) {
1681 desc.lower *= _session.frame_rate ();
1682 desc.upper *= _session.frame_rate ();
1685 desc.min_unbound = false; // TODO: LV2 extension required
1686 desc.max_unbound = false; // TODO: LV2 extension required
1688 desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1689 desc.scale_points = get_scale_points(which);
1691 desc.update_steps();
1693 lilv_node_free(def);
1694 lilv_node_free(min);
1695 lilv_node_free(max);
1696 lilv_nodes_free(portunits);
1702 LV2Plugin::describe_parameter(Evoral::Parameter which)
1704 if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1706 if (lilv_port_has_property(_impl->plugin,
1707 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1708 return X_("hidden");
1711 if (lilv_port_has_property(_impl->plugin,
1712 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1713 return X_("hidden");
1716 if (lilv_port_has_property(_impl->plugin,
1717 lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1718 return X_("latency");
1721 LilvNode* name = lilv_port_get_name(_impl->plugin,
1722 lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1723 string ret(lilv_node_as_string(name));
1724 lilv_node_free(name);
1732 LV2Plugin::signal_latency() const
1734 if (_latency_control_port) {
1735 return (framecnt_t)floor(*_latency_control_port);
1741 set<Evoral::Parameter>
1742 LV2Plugin::automatable() const
1744 set<Evoral::Parameter> ret;
1746 for (uint32_t i = 0; i < parameter_count(); ++i) {
1747 if (parameter_is_input(i) && parameter_is_control(i)) {
1748 ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1752 for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1753 p != _property_descriptors.end();
1755 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1761 LV2Plugin::activate()
1763 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1765 if (!_was_activated) {
1766 lilv_instance_activate(_impl->instance);
1767 _was_activated = true;
1772 LV2Plugin::deactivate()
1774 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1776 if (_was_activated) {
1777 lilv_instance_deactivate(_impl->instance);
1778 _was_activated = false;
1783 LV2Plugin::cleanup()
1785 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1789 lilv_instance_free(_impl->instance);
1790 _impl->instance = NULL;
1794 LV2Plugin::allocate_atom_event_buffers()
1796 /* reserve local scratch buffers for ATOM event-queues */
1797 const LilvPlugin* p = _impl->plugin;
1799 /* count non-MIDI atom event-ports
1800 * TODO: nicely ask drobilla to make a lilv_ call for that
1802 int count_atom_out = 0;
1803 int count_atom_in = 0;
1804 int minimumSize = 32768; // TODO use a per-port minimum-size
1805 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1806 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1807 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1808 LilvNodes* buffer_types = lilv_port_get_value(
1809 p, port, _world.atom_bufferType);
1810 LilvNodes* atom_supports = lilv_port_get_value(
1811 p, port, _world.atom_supports);
1813 if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1814 || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1815 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1818 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1821 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1822 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1823 if (min_size && lilv_node_is_int(min_size)) {
1824 minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1826 lilv_nodes_free(min_size_v);
1828 lilv_nodes_free(buffer_types);
1829 lilv_nodes_free(atom_supports);
1833 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1834 name(), count_atom_in, count_atom_out));
1836 const int total_atom_buffers = (count_atom_in + count_atom_out);
1837 if (_atom_ev_buffers || total_atom_buffers == 0) {
1841 DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1842 _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1843 for (int i = 0; i < total_atom_buffers; ++i ) {
1844 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1845 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1847 _atom_ev_buffers[total_atom_buffers] = 0;
1851 /** Write an ardour position/time/tempo/meter as an LV2 event.
1852 * @return true on success.
1855 write_position(LV2_Atom_Forge* forge,
1857 const TempoMetric& t,
1858 Timecode::BBT_Time& bbt,
1860 framepos_t position,
1863 const URIMap::URIDs& urids = URIMap::instance().urids;
1865 uint8_t pos_buf[256];
1866 lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1867 LV2_Atom_Forge_Frame frame;
1868 #ifdef HAVE_LV2_1_10_0
1869 lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1870 lv2_atom_forge_key(forge, urids.time_frame);
1871 lv2_atom_forge_long(forge, position);
1872 lv2_atom_forge_key(forge, urids.time_speed);
1873 lv2_atom_forge_float(forge, speed);
1874 lv2_atom_forge_key(forge, urids.time_barBeat);
1875 lv2_atom_forge_float(forge, bbt.beats - 1 +
1876 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1877 lv2_atom_forge_key(forge, urids.time_bar);
1878 lv2_atom_forge_long(forge, bbt.bars - 1);
1879 lv2_atom_forge_key(forge, urids.time_beatUnit);
1880 lv2_atom_forge_int(forge, t.meter().note_divisor());
1881 lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1882 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1883 lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1884 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1886 lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1887 lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1888 lv2_atom_forge_long(forge, position);
1889 lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1890 lv2_atom_forge_float(forge, speed);
1891 lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1892 lv2_atom_forge_float(forge, bbt.beats - 1 +
1893 (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1894 lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1895 lv2_atom_forge_long(forge, bbt.bars - 1);
1896 lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1897 lv2_atom_forge_int(forge, t.meter().note_divisor());
1898 lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1899 lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1900 lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1901 lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1904 LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
1905 const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1906 return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1907 (const uint8_t*)(atom + 1));
1911 LV2Plugin::connect_and_run(BufferSet& bufs,
1912 ChanMapping in_map, ChanMapping out_map,
1913 pframes_t nframes, framecnt_t offset)
1915 DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1916 Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1918 cycles_t then = get_cycles();
1920 TempoMap& tmap = _session.tempo_map();
1921 Metrics::const_iterator metric_i = tmap.metrics_end();
1922 TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
1924 if (_freewheel_control_port) {
1925 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
1928 if (_bpm_control_port) {
1929 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1932 ChanCount bufs_count;
1933 bufs_count.set(DataType::AUDIO, 1);
1934 bufs_count.set(DataType::MIDI, 1);
1935 BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
1936 BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1937 uint32_t const num_ports = parameter_count();
1938 uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1940 uint32_t audio_in_index = 0;
1941 uint32_t audio_out_index = 0;
1942 uint32_t midi_in_index = 0;
1943 uint32_t midi_out_index = 0;
1944 uint32_t atom_port_index = 0;
1945 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1947 uint32_t index = nil_index;
1948 PortFlags flags = _port_flags[port_index];
1950 if (flags & PORT_AUDIO) {
1951 if (flags & PORT_INPUT) {
1952 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1954 ? bufs.get_audio(index).data(offset)
1955 : silent_bufs.get_audio(0).data(offset);
1957 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1959 ? bufs.get_audio(index).data(offset)
1960 : scratch_bufs.get_audio(0).data(offset);
1962 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1963 /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1964 be necessary, but the mapping is illegal in some cases. Ideally
1965 that should be fixed, but this is easier...
1967 if (flags & PORT_MIDI) {
1968 if (flags & PORT_INPUT) {
1969 index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1971 index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1973 if (valid && bufs.count().n_midi() > index) {
1974 /* Note, ensure_lv2_bufsize() is not RT safe!
1975 * However free()/alloc() is only called if a
1976 * plugin requires a rsz:minimumSize buffersize
1977 * and the existing buffer if smaller.
1979 bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1980 _ev_buffers[port_index] = bufs.get_lv2_midi(
1981 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1983 } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1984 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1985 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1989 if (valid && (flags & PORT_INPUT)) {
1990 Timecode::BBT_Time bbt;
1991 if ((flags & PORT_POSITION)) {
1992 if (_session.transport_frame() != _next_cycle_start ||
1993 _session.transport_speed() != _next_cycle_speed) {
1994 // Transport has changed, write position at cycle start
1995 tmap.bbt_time(_session.transport_frame(), bbt);
1996 write_position(&_impl->forge, _ev_buffers[port_index],
1997 tmetric, bbt, _session.transport_speed(),
1998 _session.transport_frame(), 0);
2002 // Get MIDI iterator range (empty range if no MIDI)
2003 MidiBuffer::iterator m = (index != nil_index)
2004 ? bufs.get_midi(index).begin()
2005 : silent_bufs.get_midi(0).end();
2006 MidiBuffer::iterator m_end = (index != nil_index)
2007 ? bufs.get_midi(index).end()
2010 // Now merge MIDI and any transport events into the buffer
2011 const uint32_t type = _uri_map.urids.midi_MidiEvent;
2012 const framepos_t tend = _session.transport_frame() + nframes;
2014 while (m != m_end || (metric_i != tmap.metrics_end() &&
2015 (*metric_i)->frame() < tend)) {
2016 MetricSection* metric = (metric_i != tmap.metrics_end())
2018 if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2019 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2020 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2021 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2024 tmetric.set_metric(metric);
2025 bbt = metric->start();
2026 write_position(&_impl->forge, _ev_buffers[port_index],
2027 tmetric, bbt, _session.transport_speed(),
2029 metric->frame() - _session.transport_frame());
2033 } else if (!valid) {
2034 // Nothing we understand or care about, connect to scratch
2035 // see note for midi-buffer size above
2036 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2037 0, _port_minimumSize[port_index]);
2038 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2039 (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2042 buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2044 continue; // Control port, leave buffer alone
2046 lilv_instance_connect_port(_impl->instance, port_index, buf);
2049 // Read messages from UI and push into appropriate buffers
2051 uint32_t read_space = _from_ui->read_space();
2052 while (read_space > sizeof(UIMessage)) {
2054 if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2055 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2058 vector<uint8_t> body(msg.size);
2059 if (_from_ui->read(&body[0], msg.size) != msg.size) {
2060 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2063 if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2064 LV2_Evbuf* buf = _ev_buffers[msg.index];
2065 LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2066 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2067 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2068 (const uint8_t*)(atom + 1))) {
2069 error << "Failed to write data to LV2 event buffer\n";
2072 error << "Received unknown message type from UI" << endmsg;
2074 read_space -= sizeof(UIMessage) + msg.size;
2081 for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2082 PortFlags flags = _port_flags[port_index];
2085 /* TODO ask drobilla about comment
2086 * "Make Ardour event buffers generic so plugins can communicate"
2087 * in libs/ardour/buffer_set.cc:310
2089 * ideally the user could choose which of the following two modes
2090 * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2092 * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2093 * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2094 * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2095 * for quite a while at least ;)
2097 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2098 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2099 const uint32_t buf_index = out_map.get(
2100 DataType::MIDI, midi_out_index++, &valid);
2102 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2105 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2106 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2107 const uint32_t buf_index = out_map.get(
2108 DataType::MIDI, midi_out_index++, &valid);
2110 bufs.flush_lv2_midi(true, buf_index);
2115 // Write messages to UI
2116 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2117 (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2118 LV2_Evbuf* buf = _ev_buffers[port_index];
2119 for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2120 lv2_evbuf_is_valid(i);
2121 i = lv2_evbuf_next(i)) {
2122 uint32_t frames, subframes, type, size;
2124 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2126 // Intercept patch change messages to emit PropertyChanged signal
2127 if ((flags & PORT_PATCHMSG)) {
2128 LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2129 if (atom->type == _uri_map.urids.atom_Blank ||
2130 atom->type == _uri_map.urids.atom_Object) {
2131 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2132 if (obj->body.otype == _uri_map.urids.patch_Set) {
2133 const LV2_Atom* property = NULL;
2134 const LV2_Atom* value = NULL;
2135 lv2_atom_object_get(obj,
2136 _uri_map.urids.patch_property, &property,
2137 _uri_map.urids.patch_value, &value,
2140 if (!property || !value ||
2141 property->type != _uri_map.urids.atom_URID ||
2142 value->type != _uri_map.urids.atom_Path) {
2143 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2147 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2148 const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2150 // Emit PropertyChanged signal for UI
2151 // TODO: This should emit the control's Changed signal
2152 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2157 if (!_to_ui) continue;
2158 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2159 size + sizeof(LV2_Atom),
2160 data - sizeof(LV2_Atom));
2165 cycles_t now = get_cycles();
2166 set_cycles((uint32_t)(now - then));
2168 // Update expected transport information for next cycle so we can detect changes
2169 _next_cycle_speed = _session.transport_speed();
2170 _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2176 LV2Plugin::parameter_is_control(uint32_t param) const
2178 assert(param < _port_flags.size());
2179 return _port_flags[param] & PORT_CONTROL;
2183 LV2Plugin::parameter_is_audio(uint32_t param) const
2185 assert(param < _port_flags.size());
2186 return _port_flags[param] & PORT_AUDIO;
2190 LV2Plugin::parameter_is_event(uint32_t param) const
2192 assert(param < _port_flags.size());
2193 return _port_flags[param] & PORT_EVENT;
2197 LV2Plugin::parameter_is_output(uint32_t param) const
2199 assert(param < _port_flags.size());
2200 return _port_flags[param] & PORT_OUTPUT;
2204 LV2Plugin::parameter_is_input(uint32_t param) const
2206 assert(param < _port_flags.size());
2207 return _port_flags[param] & PORT_INPUT;
2211 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2214 if (param < parameter_count()) {
2215 snprintf(buf, len, "%.3f", get_parameter(param));
2222 boost::shared_ptr<ScalePoints>
2223 LV2Plugin::get_scale_points(uint32_t port_index) const
2225 const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2226 LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2228 boost::shared_ptr<ScalePoints> ret;
2233 ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2235 LILV_FOREACH(scale_points, i, points) {
2236 const LilvScalePoint* p = lilv_scale_points_get(points, i);
2237 const LilvNode* label = lilv_scale_point_get_label(p);
2238 const LilvNode* value = lilv_scale_point_get_value(p);
2239 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2240 ret->insert(make_pair(lilv_node_as_string(label),
2241 lilv_node_as_float(value)));
2245 lilv_scale_points_free(points);
2250 LV2Plugin::run(pframes_t nframes)
2252 uint32_t const N = parameter_count();
2253 for (uint32_t i = 0; i < N; ++i) {
2254 if (parameter_is_control(i) && parameter_is_input(i)) {
2255 _control_data[i] = _shadow_data[i];
2259 lilv_instance_run(_impl->instance, nframes);
2261 if (_impl->work_iface) {
2262 _worker->emit_responses();
2263 if (_impl->work_iface->end_run) {
2264 _impl->work_iface->end_run(_impl->instance->lv2_handle);
2270 LV2Plugin::latency_compute_run()
2272 if (!_latency_control_port) {
2276 // Run the plugin so that it can set its latency parameter
2278 bool was_activated = _was_activated;
2281 uint32_t port_index = 0;
2282 uint32_t in_index = 0;
2283 uint32_t out_index = 0;
2285 // this is done in the main thread. non realtime.
2286 const framecnt_t bufsize = _engine.samples_per_cycle();
2287 float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2289 memset(buffer, 0, sizeof(float) * bufsize);
2291 // FIXME: Ensure plugins can handle in-place processing
2295 while (port_index < parameter_count()) {
2296 if (parameter_is_audio(port_index)) {
2297 if (parameter_is_input(port_index)) {
2298 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2300 } else if (parameter_is_output(port_index)) {
2301 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2310 if (was_activated) {
2317 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2319 const LilvPort* port = NULL;
2320 LilvNode* designation = lilv_new_uri(_world.world, uri);
2321 port = lilv_plugin_get_port_by_designation(
2322 plugin, _world.lv2_InputPort, designation);
2323 lilv_node_free(designation);
2325 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2330 static bool lv2_filter (const string& str, void* /*arg*/)
2332 /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2334 return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2338 LV2World::LV2World()
2339 : world(lilv_world_new())
2340 , _bundle_checked(false)
2342 atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2343 atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2344 atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2345 atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2346 atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2347 atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2348 ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2349 ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2350 ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2351 lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2352 lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2353 lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2354 lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2355 lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2356 lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2357 lv2_default = lilv_new_uri(world, LV2_CORE__default);
2358 lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2359 lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2360 lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2361 lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2362 lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2363 lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2364 lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2365 midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2366 rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2367 rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2368 rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2369 rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2370 time_Position = lilv_new_uri(world, LV2_TIME__Position);
2371 ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2372 ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2373 ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2374 units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2375 units_render = lilv_new_uri(world, LV2_UNITS__render);
2376 units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2377 units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2378 units_db = lilv_new_uri(world, LV2_UNITS__db);
2379 patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2380 patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2383 LV2World::~LV2World()
2385 lilv_node_free(patch_Message);
2386 lilv_node_free(patch_writable);
2387 lilv_node_free(units_hz);
2388 lilv_node_free(units_midiNote);
2389 lilv_node_free(units_db);
2390 lilv_node_free(units_unit);
2391 lilv_node_free(units_render);
2392 lilv_node_free(ui_externalkx);
2393 lilv_node_free(ui_external);
2394 lilv_node_free(ui_GtkUI);
2395 lilv_node_free(time_Position);
2396 lilv_node_free(rsz_minimumSize);
2397 lilv_node_free(rdfs_comment);
2398 lilv_node_free(rdfs_label);
2399 lilv_node_free(rdfs_range);
2400 lilv_node_free(midi_MidiEvent);
2401 lilv_node_free(lv2_enumeration);
2402 lilv_node_free(lv2_freewheeling);
2403 lilv_node_free(lv2_toggled);
2404 lilv_node_free(lv2_sampleRate);
2405 lilv_node_free(lv2_reportsLatency);
2406 lilv_node_free(lv2_integer);
2407 lilv_node_free(lv2_inPlaceBroken);
2408 lilv_node_free(lv2_OutputPort);
2409 lilv_node_free(lv2_InputPort);
2410 lilv_node_free(lv2_ControlPort);
2411 lilv_node_free(lv2_AudioPort);
2412 lilv_node_free(ext_notOnGUI);
2413 lilv_node_free(ext_logarithmic);
2414 lilv_node_free(ev_EventPort);
2415 lilv_node_free(atom_supports);
2416 lilv_node_free(atom_eventTransfer);
2417 lilv_node_free(atom_bufferType);
2418 lilv_node_free(atom_Sequence);
2419 lilv_node_free(atom_Chunk);
2420 lilv_node_free(atom_AtomPort);
2421 lilv_world_free(world);
2425 LV2World::load_bundled_plugins(bool verbose)
2427 if (!_bundle_checked) {
2429 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2432 vector<string> plugin_objects;
2433 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2434 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2435 #ifdef PLATFORM_WINDOWS
2436 string uri = "file:///" + *x + "/";
2438 string uri = "file://" + *x + "/";
2440 LilvNode *node = lilv_new_uri(world, uri.c_str());
2441 lilv_world_load_bundle(world, node);
2442 lilv_node_free(node);
2445 lilv_world_load_all(world);
2446 _bundle_checked = true;
2450 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2453 _plugin_uri = strdup(plugin_uri);
2456 LV2PluginInfo::~LV2PluginInfo()
2463 LV2PluginInfo::load(Session& session)
2467 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2468 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2469 if (!uri) { throw failed_constructor(); }
2470 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2471 if (!lp) { throw failed_constructor(); }
2472 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2473 lilv_node_free(uri);
2474 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2476 } catch (failed_constructor& err) {
2477 return PluginPtr((Plugin*)0);
2484 LV2PluginInfo::discover()
2487 world.load_bundled_plugins();
2488 _world.load_bundled_plugins(true);
2490 PluginInfoList* plugs = new PluginInfoList;
2491 const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2493 LILV_FOREACH(plugins, i, plugins) {
2494 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2495 const LilvNode* pun = lilv_plugin_get_uri(p);
2497 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2499 LilvNode* name = lilv_plugin_get_name(p);
2500 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2501 warning << "Ignoring invalid LV2 plugin "
2502 << lilv_node_as_string(lilv_plugin_get_uri(p))
2509 info->name = string(lilv_node_as_string(name));
2510 lilv_node_free(name);
2511 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2513 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2514 const LilvNode* label = lilv_plugin_class_get_label(pclass);
2515 info->category = lilv_node_as_string(label);
2517 LilvNode* author_name = lilv_plugin_get_author_name(p);
2518 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2519 lilv_node_free(author_name);
2521 info->path = "/NOPATH"; // Meaningless for LV2
2523 /* count atom-event-ports that feature
2524 * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2526 * TODO: nicely ask drobilla to make a lilv_ call for that
2528 int count_midi_out = 0;
2529 int count_midi_in = 0;
2530 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2531 const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2532 if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2533 LilvNodes* buffer_types = lilv_port_get_value(
2534 p, port, world.atom_bufferType);
2535 LilvNodes* atom_supports = lilv_port_get_value(
2536 p, port, world.atom_supports);
2538 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2539 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2540 if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2543 if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2547 lilv_nodes_free(buffer_types);
2548 lilv_nodes_free(atom_supports);
2552 info->n_inputs.set_audio(
2553 lilv_plugin_get_num_ports_of_class(
2554 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2555 info->n_inputs.set_midi(
2556 lilv_plugin_get_num_ports_of_class(
2557 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2560 info->n_outputs.set_audio(
2561 lilv_plugin_get_num_ports_of_class(
2562 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2563 info->n_outputs.set_midi(
2564 lilv_plugin_get_num_ports_of_class(
2565 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2568 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2569 info->index = 0; // Meaningless for LV2
2571 plugs->push_back(info);