ardour
lv2_plugin.cc
Go to the documentation of this file.
1 /*
2  Copyright (C) 2008-2012 Paul Davis
3  Author: David Robillard
4 
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.
9 
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.
14 
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.
18 */
19 
20 #include <string>
21 #include <vector>
22 #include <limits>
23 
24 #include <cmath>
25 #include <cstdlib>
26 #include <cstring>
27 
28 #include <glib/gstdio.h>
29 #include <glib/gprintf.h>
30 #include <glibmm.h>
31 
32 #include <boost/utility.hpp>
33 
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"
39 
40 #include "libardour-config.h"
41 
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"
52 
53 #include "i18n.h"
54 #include <locale.h>
55 
56 #include <lilv/lilv.h>
57 
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"
71 #ifdef HAVE_LV2_1_2_0
72 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
73 #include "lv2/lv2plug.in/ns/ext/options/options.h"
74 #endif
75 
76 #include "lv2_evbuf.h"
77 
78 #ifdef HAVE_SUIL
79 #include <suil/suil.h>
80 #endif
81 
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)))
86 #endif
87 #ifndef LV2_ATOM_BODY_CONST
88 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
89 #endif
90 #ifndef LV2_PATCH__property
91 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
92 #endif
93 #ifndef LV2_PATCH__value
94 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
95 #endif
96 #ifndef LV2_PATCH__writable
97 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
98 #endif
99 
104 static const size_t NBUFS = 4;
105 
106 using namespace std;
107 using namespace ARDOUR;
108 using namespace PBD;
109 
110 class LV2World : boost::noncopyable {
111 public:
112  LV2World ();
113  ~LV2World ();
114 
115  void load_bundled_plugins(bool verbose=false);
116 
117  LilvWorld* world;
118 
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;
148  LilvNode* ui_GtkUI;
149  LilvNode* ui_external;
150  LilvNode* ui_externalkx;
151  LilvNode* units_hz;
152  LilvNode* units_db;
153  LilvNode* units_unit;
154  LilvNode* units_render;
155  LilvNode* units_midiNote;
156  LilvNode* patch_writable;
157  LilvNode* patch_Message;
158 
159 private:
160  bool _bundle_checked;
161 };
162 
163 static LV2World _world;
164 
165 /* worker extension */
166 
168 static LV2_Worker_Status
169 work_schedule(LV2_Worker_Schedule_Handle handle,
170  uint32_t size,
171  const void* data)
172 {
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);
177  } else {
178  // Enqueue message for the worker thread
179  return plugin->worker()->schedule(size, data) ?
180  LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
181  }
182 }
183 
185 static LV2_Worker_Status
186 work_respond(LV2_Worker_Respond_Handle handle,
187  uint32_t size,
188  const void* data)
189 {
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);
194  } else {
195  // Enqueue response for the worker
196  return plugin->worker()->respond(size, data) ?
197  LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
198  }
199 }
200 
201 /* log extension */
202 
203 static int
204 log_vprintf(LV2_Log_Handle /*handle*/,
205  LV2_URID type,
206  const char* fmt,
207  va_list args)
208 {
209  char* str = NULL;
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;
217  }
218  // TODO: Toggleable log:Trace message support
219  return ret;
220 }
221 
222 static int
223 log_printf(LV2_Log_Handle handle,
224  LV2_URID type,
225  const char* fmt, ...)
226 {
227  va_list args;
228  va_start(args, fmt);
229  const int ret = log_vprintf(handle, type, fmt, args);
230  va_end(args);
231  return ret;
232 }
233 
234 struct LV2Plugin::Impl {
235  Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
236  , work_iface(0)
237  , state(0)
238  {}
239 
243  const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
244 
245  const LilvPlugin* plugin;
246  const LilvUI* ui;
247  const LilvNode* ui_type;
248  LilvNode* name;
249  LilvNode* author;
250  LilvInstance* instance;
251  const LV2_Worker_Interface* work_iface;
252  LilvState* state;
253  LV2_Atom_Forge forge;
254  LV2_Atom_Forge ui_forge;
255 };
256 
257 LV2Plugin::LV2Plugin (AudioEngine& engine,
258  Session& session,
259  const void* c_plugin,
260  framecnt_t rate)
261  : Plugin (engine, session)
262  , Workee ()
263  , _impl(new Impl())
264  , _features(NULL)
265  , _worker(NULL)
266  , _insert_id("0")
267  , _patch_port_in_index((uint32_t)-1)
268  , _patch_port_out_index((uint32_t)-1)
269  , _uri_map(URIMap::instance())
270 {
271  init(c_plugin, rate);
272 }
273 
274 LV2Plugin::LV2Plugin (const LV2Plugin& other)
275  : Plugin (other)
276  , Workee ()
277  , _impl(new Impl())
278  , _features(NULL)
279  , _worker(NULL)
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())
284 {
285  init(other._impl->plugin, other._sample_rate);
286 
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];
290  }
291 }
292 
293 void
294 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
295 {
296  DEBUG_TRACE(DEBUG::LV2, "init\n");
297 
298  _impl->plugin = (const LilvPlugin*)c_plugin;
299  _impl->ui = NULL;
300  _impl->ui_type = NULL;
301  _to_ui = NULL;
302  _from_ui = NULL;
303  _control_data = 0;
304  _shadow_data = 0;
305  _atom_ev_buffers = 0;
306  _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);
314  _state_version = 0;
315  _was_activated = false;
316  _has_state_interface = false;
317 
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;
326 
327  const LilvPlugin* plugin = _impl->plugin;
328 
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);
338 
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;
347 
348  unsigned n_features = 7;
349 #ifdef HAVE_LV2_1_2_0
350  _features[n_features++] = &_def_state_feature;
351 #endif
352 
353  lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
354  lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
355 
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 }
366  };
367 
368  _options_feature.URI = LV2_OPTIONS__options;
369  _options_feature.data = options;
370  _features[n_features++] = &_options_feature;
371 #endif
372 
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;
378 
379  LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
380  log->handle = this;
381  log->printf = &log_printf;
382  log->vprintf = &log_vprintf;
383  _log_feature.data = log;
384 
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;
395  }
396  lilv_node_free(worker_schedule);
397 
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);
401 
402  if (_impl->instance == 0) {
403  error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
404  throw failed_constructor();
405  }
406 
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;
410 
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);
415  }
416  lilv_node_free(worker_iface_uri);
417 
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();
425  }
426 
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);
433  }
434 #endif
435 
436  _sample_rate = rate;
437 
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);
441  PortFlags flags = 0;
442  size_t minimumSize = 0;
443 
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)) {
447  flags |= PORT_INPUT;
448  } else {
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();
453  }
454 
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)) {
458  flags |= PORT_AUDIO;
459  } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
460  flags |= PORT_EVENT;
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);
467 
468  if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
469  flags |= PORT_SEQUENCE;
470  if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
471  flags |= PORT_MIDI;
472  }
473  if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
474  flags |= PORT_POSITION;
475  }
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;
480  } else {
481  _patch_port_out_index = i;
482  }
483  }
484  }
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);
489  }
490  lilv_nodes_free(min_size_v);
491  lilv_nodes_free(buffer_types);
492  lilv_nodes_free(atom_supports);
493  } else {
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();
498  }
499 
500  _port_flags.push_back(flags);
501  _port_minimumSize.push_back(minimumSize);
502  }
503 
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);
509 
510  const bool latent = lilv_plugin_has_latency(plugin);
511  const uint32_t latency_index = (latent)
512  ? lilv_plugin_get_latency_port_index(plugin)
513  : 0;
514 
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) {
518  params[i] = NULL;
519  }
520  _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
521  _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
522 
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);
526 
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));
529 
530  // Get range and default value if applicable
531  if (parameter_is_control(i)) {
532  LilvNode* def;
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 ();
537  }
538  lilv_node_free(def);
539 
540  lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
541 
542  if (latent && i == latency_index) {
543  _latency_control_port = &_control_data[i];
544  *_latency_control_port = 0;
545  }
546 
547  if (parameter_is_input(i)) {
548  _shadow_data[i] = default_value(i);
549  if (params[i]) {
550  *params[i] = (void*)&_shadow_data[i];
551  }
552  }
553  } else {
554  _defaults[i] = 0.0f;
555  }
556  }
557 
558  delete[] params;
559 
560  LilvUIs* uis = lilv_plugin_get_uis(plugin);
561  if (lilv_uis_size(uis) > 0) {
562 #ifdef HAVE_SUIL
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,
568  suil_ui_supported,
569  _world.ui_GtkUI,
570  &this_ui_type)) {
571  // TODO: Multiple UI support
572  _impl->ui = this_ui;
573  _impl->ui_type = this_ui_type;
574  break;
575  }
576  }
577 #else
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)) {
582  _impl->ui = ui;
583  _impl->ui_type = _world.ui_GtkUI;
584  break;
585  }
586  }
587 #endif
588 
589  // If Gtk UI is not available, try to find external UI
590  if (!_impl->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)) {
594  _impl->ui = ui;
595  _impl->ui_type = _world.ui_external;
596  break;
597  }
598  if (lilv_ui_is_a(ui, _world.ui_external)) {
599  _impl->ui = ui;
600  _impl->ui_type = _world.ui_external;
601  }
602  }
603  }
604  }
605 
606  load_supported_properties(_property_descriptors);
607  allocate_atom_event_buffers();
608  latency_compute_run();
609 }
610 
611 LV2Plugin::~LV2Plugin ()
612 {
613  DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
614 
615  deactivate();
616  cleanup();
617 
618  lilv_instance_free(_impl->instance);
619  lilv_node_free(_impl->name);
620  lilv_node_free(_impl->author);
621 
622  free(_features);
623  free(_make_path_feature.data);
624  free(_work_schedule_feature.data);
625 
626  delete _to_ui;
627  delete _from_ui;
628  delete _worker;
629 
630  if (_atom_ev_buffers) {
631  LV2_Evbuf** b = _atom_ev_buffers;
632  while (*b) {
633  free(*b);
634  b++;
635  }
636  free(_atom_ev_buffers);
637  }
638 
639  delete [] _control_data;
640  delete [] _shadow_data;
641  delete [] _ev_buffers;
642 }
643 
644 bool
645 LV2Plugin::is_external_ui() const
646 {
647  if (!_impl->ui) {
648  return false;
649  }
650  return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
651 }
652 
653 bool
654 LV2Plugin::is_external_kx() const
655 {
656  if (!_impl->ui) {
657  return false;
658  }
659  return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
660 }
661 
662 bool
663 LV2Plugin::ui_is_resizable () const
664 {
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);
669 
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);
672 
673  lilv_nodes_free(nrs_matches);
674  lilv_nodes_free(fs_matches);
675  lilv_node_free(nrs);
676  lilv_node_free(fs);
677  lilv_node_free(p);
678 
679  return !fs_matches && !nrs_matches;
680 }
681 
682 string
683 LV2Plugin::unique_id() const
684 {
685  return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
686 }
687 
688 const char*
689 LV2Plugin::uri() const
690 {
691  return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
692 }
693 
694 const char*
695 LV2Plugin::label() const
696 {
697  return lilv_node_as_string(_impl->name);
698 }
699 
700 const char*
701 LV2Plugin::name() const
702 {
703  return lilv_node_as_string(_impl->name);
704 }
705 
706 const char*
707 LV2Plugin::maker() const
708 {
709  return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
710 }
711 
712 uint32_t
713 LV2Plugin::num_ports() const
714 {
715  return lilv_plugin_get_num_ports(_impl->plugin);
716 }
717 
718 uint32_t
719 LV2Plugin::parameter_count() const
720 {
721  return lilv_plugin_get_num_ports(_impl->plugin);
722 }
723 
724 float
725 LV2Plugin::default_value(uint32_t port)
726 {
727  return _defaults[port];
728 }
729 
730 const char*
731 LV2Plugin::port_symbol(uint32_t index) const
732 {
733  const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
734  if (!port) {
735  error << name() << ": Invalid port index " << index << endmsg;
736  }
737 
738  const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
739  return lilv_node_as_string(sym);
740 }
741 
742 uint32_t
743 LV2Plugin::port_index (const char* symbol) const
744 {
745  const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
746  if (i != _port_indices.end()) {
747  return i->second;
748  } else {
749  warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
750  return (uint32_t)-1;
751  }
752 }
753 
754 void
755 LV2Plugin::set_parameter(uint32_t which, float val)
756 {
757  DEBUG_TRACE(DEBUG::LV2, string_compose(
758  "%1 set parameter %2 to %3\n", name(), which, val));
759 
760  if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
761  if (get_parameter (which) == val) {
762  return;
763  }
764 
765  _shadow_data[which] = val;
766  } else {
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;
771  }
772 
773  Plugin::set_parameter(which, val);
774 }
775 
776 float
777 LV2Plugin::get_parameter(uint32_t which) const
778 {
779  if (parameter_is_input(which)) {
780  return (float)_shadow_data[which];
781  } else {
782  return (float)_control_data[which];
783  }
784  return 0.0f;
785 }
786 
787 std::string
788 LV2Plugin::get_docs() const
789 {
790  LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
791  if (comments) {
792  const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
793  lilv_nodes_free(comments);
794  return docs;
795  }
796 
797  return "";
798 }
799 
800 std::string
801 LV2Plugin::get_parameter_docs(uint32_t which) const
802 {
803  LilvNodes* comments = lilv_port_get_value(
804  _impl->plugin,
805  lilv_plugin_get_port_by_index(_impl->plugin, which),
806  _world.rdfs_comment);
807 
808  if (comments) {
809  const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
810  lilv_nodes_free(comments);
811  return docs;
812  }
813 
814  return "";
815 }
816 
817 uint32_t
818 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
819 {
820  ok = false;
821  for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
822  if (parameter_is_control(x)) {
823  if (c++ == n) {
824  ok = true;
825  return x;
826  }
827  }
828  }
829 
830  return 0;
831 }
832 
833 const void*
834 LV2Plugin::extension_data(const char* uri) const
835 {
836  return lilv_instance_get_extension_data(_impl->instance, uri);
837 }
838 
839 const void*
840 LV2Plugin::c_plugin()
841 {
842  return _impl->plugin;
843 }
844 
845 const void*
846 LV2Plugin::c_ui()
847 {
848  return (const void*)_impl->ui;
849 }
850 
851 const void*
852 LV2Plugin::c_ui_type()
853 {
854  return (const void*)_impl->ui_type;
855 }
856 
858 const std::string
859 LV2Plugin::plugin_dir() const
860 {
861  return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
862 }
863 
865 const std::string
866 LV2Plugin::scratch_dir() const
867 {
868  return Glib::build_filename(plugin_dir(), "scratch");
869 }
870 
872 const std::string
873 LV2Plugin::file_dir() const
874 {
875  return Glib::build_filename(plugin_dir(), "files");
876 }
877 
879 const std::string
880 LV2Plugin::state_dir(unsigned num) const
881 {
882  return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
883 }
884 
888 char*
889 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
890  const char* path)
891 {
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);
898  }
899 
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);
903 
904  DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
905  path, abs_path));
906 
907  return g_strndup(abs_path.c_str(), abs_path.length());
908 }
909 
910 void
911 LV2Plugin::add_state(XMLNode* root) const
912 {
913  assert(_insert_id != PBD::ID("0"));
914 
915  XMLNode* child;
916  char buf[16];
917  LocaleGuard lg(X_("C"));
918 
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);
926  }
927  }
928 
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);
933 
934  LilvState* state = lilv_state_new_from_instance(
935  _impl->plugin,
936  _impl->instance,
937  _uri_map.urid_map(),
938  scratch_dir().c_str(),
939  file_dir().c_str(),
940  _session.externals_dir().c_str(),
941  new_dir.c_str(),
942  NULL,
943  const_cast<LV2Plugin*>(this),
944  0,
945  NULL);
946 
947  if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
948  lilv_state_save(_world.world,
949  _uri_map.urid_map(),
950  _uri_map.urid_unmap(),
951  state,
952  NULL,
953  new_dir.c_str(),
954  "state.ttl");
955 
956  lilv_state_free(_impl->state);
957  _impl->state = state;
958  } else {
959  // State is identical, decrement version and nuke directory
960  lilv_state_free(state);
961  PBD::remove_directory(new_dir);
962  --_state_version;
963  }
964 
965  root->add_property("state-dir", string_compose("state%1", _state_version));
966  }
967 }
968 
969 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
970 static LilvNode*
971 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
972 {
973  LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
974  if (vs) {
975  LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
976  lilv_nodes_free(vs);
977  return node;
978  }
979  return NULL;
980 }
981 
982 void
983 LV2Plugin::find_presets()
984 {
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");
988 
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);
994  if (name) {
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);
1000  } else {
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;
1005  }
1006  }
1007  lilv_nodes_free(presets);
1008 
1009  lilv_node_free(rdfs_label);
1010  lilv_node_free(pset_Preset);
1011  lilv_node_free(lv2_appliesTo);
1012 }
1013 
1014 static void
1015 set_port_value(const char* port_symbol,
1016  void* user_data,
1017  const void* value,
1018  uint32_t /*size*/,
1019  uint32_t type)
1020 {
1021  LV2Plugin* self = (LV2Plugin*)user_data;
1022  if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1023  return; // TODO: Support non-float ports
1024  }
1025 
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);
1029  }
1030 }
1031 
1032 bool
1033 LV2Plugin::load_preset(PresetRecord r)
1034 {
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);
1038 
1039  if (state) {
1040  lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1041  lilv_state_free(state);
1042  Plugin::load_preset(r);
1043  }
1044 
1045  lilv_node_free(pset);
1046  return state;
1047 }
1048 
1049 const void*
1050 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1051  void* user_data,
1052  uint32_t* size,
1053  uint32_t* type)
1054 {
1055  LV2Plugin *plugin = (LV2Plugin *) user_data;
1056 
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)) {
1060  float *value;
1061  *size = sizeof(float);
1062  *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1063  value = &plugin->_shadow_data[index];
1064 
1065  return value;
1066  }
1067  }
1068 
1069  *size = *type = 0;
1070  return NULL;
1071 }
1072 
1073 
1074 std::string
1075 LV2Plugin::do_save_preset(string name)
1076 {
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"));
1084 
1085  LilvState* state = lilv_state_new_from_instance(
1086  _impl->plugin,
1087  _impl->instance,
1088  _uri_map.urid_map(),
1089  scratch_dir().c_str(), // file_dir
1090  bundle.c_str(), // copy_dir
1091  bundle.c_str(), // link_dir
1092  bundle.c_str(), // save_dir
1093  lv2plugin_get_port_value, // get_value
1094  (void*)this, // user_data
1095  LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, // flags
1096  _features // features
1097  );
1098 
1099  lilv_state_set_label(state, name.c_str());
1100  lilv_state_save(
1101  _world.world, // world
1102  _uri_map.urid_map(), // map
1103  _uri_map.urid_unmap(), // unmap
1104  state, // state
1105  NULL, // uri (NULL = use file URI)
1106  bundle.c_str(), // dir
1107  file_name.c_str() // filename
1108  );
1109 
1110  lilv_state_free(state);
1111 
1112  std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1113  LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1114  LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1115 #ifdef HAVE_LILV_0_21_3
1116  lilv_world_unload_resource(_world.world, node_preset);
1117  lilv_world_unload_bundle(_world.world, node_bundle);
1118 #endif
1119  lilv_world_load_bundle(_world.world, node_bundle);
1120  lilv_world_load_resource(_world.world, node_preset);
1121  lilv_node_free(node_bundle);
1122  lilv_node_free(node_preset);
1123  lilv_node_free(plug_name);
1124  return uri;
1125 }
1126 
1127 void
1128 LV2Plugin::do_remove_preset(string name)
1129 {
1130 #ifdef HAVE_LILV_0_21_3
1131  /* Look up preset record by label (FIXME: ick, label as ID) */
1132  const PresetRecord* r = preset_by_label(name);
1133  if (!r) {
1134  return;
1135  }
1136 
1137  /* Load a LilvState for the preset. */
1138  LilvWorld* world = _world.world;
1139  LilvNode* pset = lilv_new_uri(world, r->uri.c_str());
1140  LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1141  if (!state) {
1142  lilv_node_free(pset);
1143  return;
1144  }
1145 
1146  /* Delete it from the file system. This will remove the preset file and the entry
1147  from the manifest. If this results in an empty manifest (i.e. the
1148  preset is the only thing in the bundle), then the bundle is removed. */
1149  lilv_state_delete(world, state);
1150 
1151  lilv_state_free(state);
1152  lilv_node_free(pset);
1153 #endif
1154  /* Without lilv_state_delete(), we could delete the preset file, but this
1155  would leave a broken bundle/manifest around, so the preset would still
1156  be visible, but broken. Naively deleting a bundle is too dangerous, so
1157  we simply do not support preset deletion with older Lilv */
1158 }
1159 
1160 bool
1161 LV2Plugin::has_editor() const
1162 {
1163  return _impl->ui != NULL;
1164 }
1165 
1166 bool
1167 LV2Plugin::has_message_output() const
1168 {
1169  for (uint32_t i = 0; i < num_ports(); ++i) {
1170  if ((_port_flags[i] & PORT_SEQUENCE) &&
1171  (_port_flags[i] & PORT_OUTPUT)) {
1172  return true;
1173  }
1174  }
1175  return false;
1176 }
1177 
1178 bool
1179 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1180  uint32_t index,
1181  uint32_t protocol,
1182  uint32_t size,
1183  const uint8_t* body)
1184 {
1185  const uint32_t buf_size = sizeof(UIMessage) + size;
1186  vector<uint8_t> buf(buf_size);
1187 
1188  UIMessage* msg = (UIMessage*)&buf[0];
1189  msg->index = index;
1190  msg->protocol = protocol;
1191  msg->size = size;
1192  memcpy(msg + 1, body, size);
1193 
1194  return (dest->write(&buf[0], buf_size) == buf_size);
1195 }
1196 
1197 bool
1198 LV2Plugin::write_from_ui(uint32_t index,
1199  uint32_t protocol,
1200  uint32_t size,
1201  const uint8_t* body)
1202 {
1203  if (!_from_ui) {
1204  size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1205  /* buffer data communication from plugin UI to plugin instance.
1206  * this buffer needs to potentially hold
1207  * (port's minimumSize) * (audio-periods) / (UI-periods)
1208  * bytes.
1209  *
1210  * e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1211  * ui-periods = 25 Hz (SuperRapidScreenUpdate)
1212  * default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1213  *
1214  * it is NOT safe to overflow (msg.size will be misinterpreted)
1215  */
1216  uint32_t bufsiz = 32768;
1217  if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1218  bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1219  }
1220  rbs = max((size_t) bufsiz * 8, rbs);
1221  _from_ui = new RingBuffer<uint8_t>(rbs);
1222  }
1223 
1224  if (!write_to(_from_ui, index, protocol, size, body)) {
1225  error << "Error writing from UI to plugin" << endmsg;
1226  return false;
1227  }
1228  return true;
1229 }
1230 
1231 bool
1232 LV2Plugin::write_to_ui(uint32_t index,
1233  uint32_t protocol,
1234  uint32_t size,
1235  const uint8_t* body)
1236 {
1237  if (!write_to(_to_ui, index, protocol, size, body)) {
1238  error << "Error writing from plugin to UI" << endmsg;
1239  return false;
1240  }
1241  return true;
1242 }
1243 
1244 static void
1245 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1246 {
1247  switch (value.type()) {
1248  case Variant::NOTHING:
1249  break;
1250  case Variant::BEATS:
1251  // No atom type for this, just forge a double
1252  lv2_atom_forge_double(forge, value.get_beats().to_double());
1253  break;
1254  case Variant::BOOL:
1255  lv2_atom_forge_bool(forge, value.get_bool());
1256  break;
1257  case Variant::DOUBLE:
1258  lv2_atom_forge_double(forge, value.get_double());
1259  break;
1260  case Variant::FLOAT:
1261  lv2_atom_forge_float(forge, value.get_float());
1262  break;
1263  case Variant::INT:
1264  lv2_atom_forge_int(forge, value.get_int());
1265  break;
1266  case Variant::LONG:
1267  lv2_atom_forge_long(forge, value.get_long());
1268  break;
1269  case Variant::PATH:
1270  lv2_atom_forge_path(
1271  forge, value.get_path().c_str(), value.get_path().size());
1272  break;
1273  case Variant::STRING:
1274  lv2_atom_forge_string(
1275  forge, value.get_string().c_str(), value.get_string().size());
1276  break;
1277  case Variant::URI:
1278  lv2_atom_forge_uri(
1279  forge, value.get_uri().c_str(), value.get_uri().size());
1280  break;
1281  }
1282 }
1283 
1285 static bool
1286 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1287 {
1288  if (uri == LV2_ATOM__Bool) {
1289  type = Variant::BOOL;
1290  } else if (uri == LV2_ATOM__Double) {
1291  type = Variant::DOUBLE;
1292  } else if (uri == LV2_ATOM__Float) {
1293  type = Variant::FLOAT;
1294  } else if (uri == LV2_ATOM__Int) {
1295  type = Variant::INT;
1296  } else if (uri == LV2_ATOM__Long) {
1297  type = Variant::LONG;
1298  } else if (uri == LV2_ATOM__Path) {
1299  type = Variant::PATH;
1300  } else if (uri == LV2_ATOM__String) {
1301  type = Variant::STRING;
1302  } else if (uri == LV2_ATOM__URI) {
1303  type = Variant::URI;
1304  } else {
1305  return false;
1306  }
1307  return true;
1308 }
1309 
1310 void
1311 LV2Plugin::set_property(uint32_t key, const Variant& value)
1312 {
1313  if (_patch_port_in_index == (uint32_t)-1) {
1314  error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1315  return;
1316  } else if (value.type() == Variant::NOTHING) {
1317  error << "LV2: set_property called with void value" << endmsg;
1318  return;
1319  }
1320 
1321  // Set up forge to write to temporary buffer on the stack
1322  LV2_Atom_Forge* forge = &_impl->ui_forge;
1323  LV2_Atom_Forge_Frame frame;
1324  uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1325 
1326  lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1327 
1328  // Serialize patch:Set message to set property
1329 #ifdef HAVE_LV2_1_10_0
1330  lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1331  lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1332  lv2_atom_forge_urid(forge, key);
1333  lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1334 #else
1335  lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1336  lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1337  lv2_atom_forge_urid(forge, key);
1338  lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1339 #endif
1340 
1341  forge_variant(forge, value);
1342 
1343  // Write message to UI=>Plugin ring
1344  const LV2_Atom* const atom = (const LV2_Atom*)buf;
1345  write_from_ui(_patch_port_in_index,
1346  _uri_map.urids.atom_eventTransfer,
1347  lv2_atom_total_size(atom),
1348  (const uint8_t*)atom);
1349 }
1350 
1351 const ParameterDescriptor&
1352 LV2Plugin::get_property_descriptor(uint32_t id) const
1353 {
1354  PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1355  if (p != _property_descriptors.end()) {
1356  return p->second;
1357  }
1358  return Plugin::get_property_descriptor(id);
1359 }
1360 
1361 static void
1362 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1363 {
1364  if (lilv_nodes_contains(units, _world.units_midiNote)) {
1365  desc.unit = ParameterDescriptor::MIDI_NOTE;
1366  } else if (lilv_nodes_contains(units, _world.units_db)) {
1367  desc.unit = ParameterDescriptor::DB;
1368  } else if (lilv_nodes_contains(units, _world.units_hz)) {
1369  desc.unit = ParameterDescriptor::HZ;
1370  }
1371  if (lilv_nodes_size(units) > 0) {
1372  const LilvNode* unit = lilv_nodes_get_first(units);
1373  LilvNode* render = get_value(lworld, unit, _world.units_render);
1374  if (render) {
1375  desc.print_fmt = lilv_node_as_string(render);
1376  lilv_node_free(render);
1377  }
1378  }
1379 }
1380 
1381 static void
1382 load_parameter_descriptor(LV2World& world,
1383  ParameterDescriptor& desc,
1384  Variant::Type datatype,
1385  const LilvNode* subject)
1386 {
1387  LilvWorld* lworld = _world.world;
1388  LilvNode* label = get_value(lworld, subject, _world.rdfs_label);
1389  LilvNode* def = get_value(lworld, subject, _world.lv2_default);
1390  LilvNode* minimum = get_value(lworld, subject, _world.lv2_minimum);
1391  LilvNode* maximum = get_value(lworld, subject, _world.lv2_maximum);
1392  LilvNodes* units = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1393  if (label) {
1394  desc.label = lilv_node_as_string(label);
1395  }
1396  if (def && lilv_node_is_float(def)) {
1397  desc.normal = lilv_node_as_float(def);
1398  }
1399  if (minimum && lilv_node_is_float(minimum)) {
1400  desc.lower = lilv_node_as_float(minimum);
1401  }
1402  if (maximum && lilv_node_is_float(maximum)) {
1403  desc.upper = lilv_node_as_float(maximum);
1404  }
1405  load_parameter_descriptor_units(lworld, desc, units);
1406  desc.datatype = datatype;
1407  desc.toggled |= datatype == Variant::BOOL;
1408  desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1409  desc.update_steps();
1410 
1411  lilv_nodes_free(units);
1412  lilv_node_free(label);
1413  lilv_node_free(def);
1414  lilv_node_free(minimum);
1415  lilv_node_free(maximum);
1416 }
1417 
1418 void
1419 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1420 {
1421  LilvWorld* lworld = _world.world;
1422  const LilvNode* subject = lilv_plugin_get_uri(_impl->plugin);
1423  LilvNodes* properties = lilv_world_find_nodes(
1424  lworld, subject, _world.patch_writable, NULL);
1425  LILV_FOREACH(nodes, p, properties) {
1426  // Get label and range
1427  const LilvNode* prop = lilv_nodes_get(properties, p);
1428  LilvNode* range = get_value(lworld, prop, _world.rdfs_range);
1429  if (!range) {
1430  warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1431  lilv_node_as_uri(prop)) << endmsg;
1432  continue;
1433  }
1434 
1435  // Convert range to variant type (TODO: support for multiple range types)
1436  Variant::Type datatype;
1437  if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1438  error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1439  lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1440  continue;
1441  }
1442 
1443  // Add description to result
1444  ParameterDescriptor desc;
1445  desc.key = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1446  desc.datatype = datatype;
1447  load_parameter_descriptor(_world, desc, datatype, prop);
1448  descs.insert(std::make_pair(desc.key, desc));
1449 
1450  lilv_node_free(range);
1451  }
1452  lilv_nodes_free(properties);
1453 }
1454 
1455 void
1456 LV2Plugin::announce_property_values()
1457 {
1458  if (_patch_port_in_index == (uint32_t)-1) {
1459  return;
1460  }
1461 
1462  // Set up forge to write to temporary buffer on the stack
1463  LV2_Atom_Forge* forge = &_impl->ui_forge;
1464  LV2_Atom_Forge_Frame frame;
1465  uint8_t buf[PATH_MAX]; // Ought to be enough for anyone...
1466 
1467  lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1468 
1469  // Serialize patch:Get message with no subject (implicitly plugin instance)
1470 #ifdef HAVE_LV2_1_10_0
1471  lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1472 #else
1473  lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1474 #endif
1475 
1476  // Write message to UI=>Plugin ring
1477  const LV2_Atom* const atom = (const LV2_Atom*)buf;
1478  write_from_ui(_patch_port_in_index,
1479  _uri_map.urids.atom_eventTransfer,
1480  lv2_atom_total_size(atom),
1481  (const uint8_t*)atom);
1482 }
1483 
1484 void
1485 LV2Plugin::enable_ui_emission()
1486 {
1487  if (!_to_ui) {
1488  /* see note in LV2Plugin::write_from_ui() */
1489  uint32_t bufsiz = 32768;
1490  if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1491  bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1492  }
1493  size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1494  rbs = max((size_t) bufsiz * 8, rbs);
1495  _to_ui = new RingBuffer<uint8_t>(rbs);
1496  }
1497 }
1498 
1499 void
1500 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1501 {
1502  if (!_to_ui) {
1503  return;
1504  }
1505 
1506  uint32_t read_space = _to_ui->read_space();
1507  while (read_space > sizeof(UIMessage)) {
1508  UIMessage msg;
1509  if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1510  error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1511  break;
1512  }
1513  vector<uint8_t> body(msg.size);
1514  if (_to_ui->read(&body[0], msg.size) != msg.size) {
1515  error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1516  break;
1517  }
1518 
1519  sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1520 
1521  read_space -= sizeof(msg) + msg.size;
1522  }
1523 }
1524 
1525 int
1526 LV2Plugin::work(uint32_t size, const void* data)
1527 {
1528  return _impl->work_iface->work(
1529  _impl->instance->lv2_handle, work_respond, this, size, data);
1530 }
1531 
1532 int
1533 LV2Plugin::work_response(uint32_t size, const void* data)
1534 {
1535  return _impl->work_iface->work_response(
1536  _impl->instance->lv2_handle, size, data);
1537 }
1538 
1539 void
1540 LV2Plugin::set_insert_id(PBD::ID id)
1541 {
1542  _insert_id = id;
1543 }
1544 
1545 int
1546 LV2Plugin::set_state(const XMLNode& node, int version)
1547 {
1548  XMLNodeList nodes;
1549  const XMLProperty* prop;
1550  XMLNodeConstIterator iter;
1551  XMLNode* child;
1552  const char* sym;
1553  const char* value;
1554  uint32_t port_id;
1555  LocaleGuard lg(X_("C"));
1556 
1557  if (node.name() != state_node_name()) {
1558  error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1559  return -1;
1560  }
1561 
1562 #ifndef NO_PLUGIN_STATE
1563 
1564  if (version < 3000) {
1565  nodes = node.children("port");
1566  } else {
1567  nodes = node.children("Port");
1568  }
1569 
1570  for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1571 
1572  child = *iter;
1573 
1574  if ((prop = child->property("symbol")) != 0) {
1575  sym = prop->value().c_str();
1576  } else {
1577  warning << _("LV2: port has no symbol, ignored") << endmsg;
1578  continue;
1579  }
1580 
1581  map<string, uint32_t>::iterator i = _port_indices.find(sym);
1582 
1583  if (i != _port_indices.end()) {
1584  port_id = i->second;
1585  } else {
1586  warning << _("LV2: port has unknown index, ignored") << endmsg;
1587  continue;
1588  }
1589 
1590  if ((prop = child->property("value")) != 0) {
1591  value = prop->value().c_str();
1592  } else {
1593  warning << _("LV2: port has no value, ignored") << endmsg;
1594  continue;
1595  }
1596 
1597  set_parameter(port_id, atof(value));
1598  }
1599 
1600  _state_version = 0;
1601  if ((prop = node.property("state-dir")) != 0) {
1602  if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1603  error << string_compose(
1604  "LV2: failed to parse state version from \"%1\"",
1605  prop->value()) << endmsg;
1606  }
1607 
1608  std::string state_file = Glib::build_filename(
1609  plugin_dir(),
1610  Glib::build_filename(prop->value(), "state.ttl"));
1611 
1612  LilvState* state = lilv_state_new_from_file(
1613  _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1614 
1615  lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1616  }
1617 
1618  latency_compute_run();
1619 #endif
1620 
1621  return Plugin::set_state(node, version);
1622 }
1623 
1624 int
1625 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1626 {
1627  const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1628  if (!port) {
1629  error << string_compose("LV2: get descriptor of non-existent port %1", which)
1630  << endmsg;
1631  return 1;
1632  }
1633 
1634  LilvNodes* portunits;
1635  LilvNode *def, *min, *max;
1636  lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1637  portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1638 
1639  // TODO: Once we can rely on lilv 0.18.0 being present,
1640  // load_parameter_descriptor() can be used for ports as well
1641  desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1642  desc.toggled = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1643  desc.logarithmic = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1644  desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1645  desc.label = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1646  desc.normal = def ? lilv_node_as_float(def) : 0.0f;
1647  desc.lower = min ? lilv_node_as_float(min) : 0.0f;
1648  desc.upper = max ? lilv_node_as_float(max) : 1.0f;
1649  load_parameter_descriptor_units(_world.world, desc, portunits);
1650 
1651  if (desc.sr_dependent) {
1652  desc.lower *= _session.frame_rate ();
1653  desc.upper *= _session.frame_rate ();
1654  }
1655 
1656  desc.min_unbound = false; // TODO: LV2 extension required
1657  desc.max_unbound = false; // TODO: LV2 extension required
1658 
1659  desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1660  desc.scale_points = get_scale_points(which);
1661 
1662  desc.update_steps();
1663 
1664  lilv_node_free(def);
1665  lilv_node_free(min);
1666  lilv_node_free(max);
1667  lilv_nodes_free(portunits);
1668 
1669  return 0;
1670 }
1671 
1672 string
1673 LV2Plugin::describe_parameter(Evoral::Parameter which)
1674 {
1675  if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1676 
1677  if (lilv_port_has_property(_impl->plugin,
1678  lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1679  return X_("hidden");
1680  }
1681 
1682  if (lilv_port_has_property(_impl->plugin,
1683  lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1684  return X_("hidden");
1685  }
1686 
1687  if (lilv_port_has_property(_impl->plugin,
1688  lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1689  return X_("latency");
1690  }
1691 
1692  LilvNode* name = lilv_port_get_name(_impl->plugin,
1693  lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1694  string ret(lilv_node_as_string(name));
1695  lilv_node_free(name);
1696  return ret;
1697  } else {
1698  return "??";
1699  }
1700 }
1701 
1702 framecnt_t
1703 LV2Plugin::signal_latency() const
1704 {
1705  if (_latency_control_port) {
1706  return (framecnt_t)floor(*_latency_control_port);
1707  } else {
1708  return 0;
1709  }
1710 }
1711 
1712 set<Evoral::Parameter>
1713 LV2Plugin::automatable() const
1714 {
1715  set<Evoral::Parameter> ret;
1716 
1717  for (uint32_t i = 0; i < parameter_count(); ++i) {
1718  if (parameter_is_input(i) && parameter_is_control(i)) {
1719  ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1720  }
1721  }
1722 
1723  for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1724  p != _property_descriptors.end();
1725  ++p) {
1726  ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1727  }
1728  return ret;
1729 }
1730 
1731 void
1732 LV2Plugin::activate()
1733 {
1734  DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1735 
1736  if (!_was_activated) {
1737  lilv_instance_activate(_impl->instance);
1738  _was_activated = true;
1739  }
1740 }
1741 
1742 void
1743 LV2Plugin::deactivate()
1744 {
1745  DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1746 
1747  if (_was_activated) {
1748  lilv_instance_deactivate(_impl->instance);
1749  _was_activated = false;
1750  }
1751 }
1752 
1753 void
1754 LV2Plugin::cleanup()
1755 {
1756  DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1757 
1758  activate();
1759  deactivate();
1760  lilv_instance_free(_impl->instance);
1761  _impl->instance = NULL;
1762 }
1763 
1764 void
1765 LV2Plugin::allocate_atom_event_buffers()
1766 {
1767  /* reserve local scratch buffers for ATOM event-queues */
1768  const LilvPlugin* p = _impl->plugin;
1769 
1770  /* count non-MIDI atom event-ports
1771  * TODO: nicely ask drobilla to make a lilv_ call for that
1772  */
1773  int count_atom_out = 0;
1774  int count_atom_in = 0;
1775  int minimumSize = 32768; // TODO use a per-port minimum-size
1776  for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1777  const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
1778  if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1779  LilvNodes* buffer_types = lilv_port_get_value(
1780  p, port, _world.atom_bufferType);
1781  LilvNodes* atom_supports = lilv_port_get_value(
1782  p, port, _world.atom_supports);
1783 
1784  if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1785  || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1786  if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1787  count_atom_in++;
1788  }
1789  if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1790  count_atom_out++;
1791  }
1792  LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1793  LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1794  if (min_size && lilv_node_is_int(min_size)) {
1795  minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1796  }
1797  lilv_nodes_free(min_size_v);
1798  }
1799  lilv_nodes_free(buffer_types);
1800  lilv_nodes_free(atom_supports);
1801  }
1802  }
1803 
1804  DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1805  name(), count_atom_in, count_atom_out));
1806 
1807  const int total_atom_buffers = (count_atom_in + count_atom_out);
1808  if (_atom_ev_buffers || total_atom_buffers == 0) {
1809  return;
1810  }
1811 
1812  DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1813  _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1814  for (int i = 0; i < total_atom_buffers; ++i ) {
1815  _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1816  _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1817  }
1818  _atom_ev_buffers[total_atom_buffers] = 0;
1819  return;
1820 }
1821 
1825 static bool
1826 write_position(LV2_Atom_Forge* forge,
1827  LV2_Evbuf* buf,
1828  const TempoMetric& t,
1829  Timecode::BBT_Time& bbt,
1830  double speed,
1831  framepos_t position,
1832  framecnt_t offset)
1833 {
1834  const URIMap::URIDs& urids = URIMap::instance().urids;
1835 
1836  uint8_t pos_buf[256];
1837  lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1838  LV2_Atom_Forge_Frame frame;
1839 #ifdef HAVE_LV2_1_10_0
1840  lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1841  lv2_atom_forge_key(forge, urids.time_frame);
1842  lv2_atom_forge_long(forge, position);
1843  lv2_atom_forge_key(forge, urids.time_speed);
1844  lv2_atom_forge_float(forge, speed);
1845  lv2_atom_forge_key(forge, urids.time_barBeat);
1846  lv2_atom_forge_float(forge, bbt.beats - 1 +
1847  (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1848  lv2_atom_forge_key(forge, urids.time_bar);
1849  lv2_atom_forge_long(forge, bbt.bars - 1);
1850  lv2_atom_forge_key(forge, urids.time_beatUnit);
1851  lv2_atom_forge_int(forge, t.meter().note_divisor());
1852  lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1853  lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1854  lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1855  lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1856 #else
1857  lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1858  lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1859  lv2_atom_forge_long(forge, position);
1860  lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1861  lv2_atom_forge_float(forge, speed);
1862  lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1863  lv2_atom_forge_float(forge, bbt.beats - 1 +
1864  (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1865  lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1866  lv2_atom_forge_long(forge, bbt.bars - 1);
1867  lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1868  lv2_atom_forge_int(forge, t.meter().note_divisor());
1869  lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1870  lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1871  lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1872  lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1873 #endif
1874 
1875  LV2_Evbuf_Iterator end = lv2_evbuf_end(buf);
1876  const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1877  return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1878  (const uint8_t*)(atom + 1));
1879 }
1880 
1881 int
1882 LV2Plugin::connect_and_run(BufferSet& bufs,
1883  ChanMapping in_map, ChanMapping out_map,
1884  pframes_t nframes, framecnt_t offset)
1885 {
1886  DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1887  Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1888 
1889  cycles_t then = get_cycles();
1890 
1891  TempoMap& tmap = _session.tempo_map();
1892  Metrics::const_iterator metric_i = tmap.metrics_end();
1893  TempoMetric tmetric = tmap.metric_at(_session.transport_frame(), &metric_i);
1894 
1895  if (_freewheel_control_port) {
1896  *_freewheel_control_port = _session.engine().freewheeling();
1897  }
1898 
1899  if (_bpm_control_port) {
1900  *_bpm_control_port = tmetric.tempo().beats_per_minute();
1901  }
1902 
1903  ChanCount bufs_count;
1904  bufs_count.set(DataType::AUDIO, 1);
1905  bufs_count.set(DataType::MIDI, 1);
1906  BufferSet& silent_bufs = _session.get_silent_buffers(bufs_count);
1907  BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1908  uint32_t const num_ports = parameter_count();
1909  uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1910 
1911  uint32_t audio_in_index = 0;
1912  uint32_t audio_out_index = 0;
1913  uint32_t midi_in_index = 0;
1914  uint32_t midi_out_index = 0;
1915  uint32_t atom_port_index = 0;
1916  for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1917  void* buf = NULL;
1918  uint32_t index = nil_index;
1919  PortFlags flags = _port_flags[port_index];
1920  bool valid = false;
1921  if (flags & PORT_AUDIO) {
1922  if (flags & PORT_INPUT) {
1923  index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1924  buf = (valid)
1925  ? bufs.get_audio(index).data(offset)
1926  : silent_bufs.get_audio(0).data(offset);
1927  } else {
1928  index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1929  buf = (valid)
1930  ? bufs.get_audio(index).data(offset)
1931  : scratch_bufs.get_audio(0).data(offset);
1932  }
1933  } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1934  /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1935  be necessary, but the mapping is illegal in some cases. Ideally
1936  that should be fixed, but this is easier...
1937  */
1938  if (flags & PORT_MIDI) {
1939  if (flags & PORT_INPUT) {
1940  index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1941  } else {
1942  index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1943  }
1944  if (valid && bufs.count().n_midi() > index) {
1945  /* Note, ensure_lv2_bufsize() is not RT safe!
1946  * However free()/alloc() is only called if a
1947  * plugin requires a rsz:minimumSize buffersize
1948  * and the existing buffer if smaller.
1949  */
1950  bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1951  _ev_buffers[port_index] = bufs.get_lv2_midi(
1952  (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1953  }
1954  } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1955  lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1956  _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1957  valid = true;
1958  }
1959 
1960  if (valid && (flags & PORT_INPUT)) {
1961  Timecode::BBT_Time bbt;
1962  if ((flags & PORT_POSITION)) {
1963  if (_session.transport_frame() != _next_cycle_start ||
1964  _session.transport_speed() != _next_cycle_speed) {
1965  // Transport has changed, write position at cycle start
1966  tmap.bbt_time(_session.transport_frame(), bbt);
1967  write_position(&_impl->forge, _ev_buffers[port_index],
1968  tmetric, bbt, _session.transport_speed(),
1969  _session.transport_frame(), 0);
1970  }
1971  }
1972 
1973  // Get MIDI iterator range (empty range if no MIDI)
1974  MidiBuffer::iterator m = (index != nil_index)
1975  ? bufs.get_midi(index).begin()
1976  : silent_bufs.get_midi(0).end();
1977  MidiBuffer::iterator m_end = (index != nil_index)
1978  ? bufs.get_midi(index).end()
1979  : m;
1980 
1981  // Now merge MIDI and any transport events into the buffer
1982  const uint32_t type = _uri_map.urids.midi_MidiEvent;
1983  const framepos_t tend = _session.transport_frame() + nframes;
1984  ++metric_i;
1985  while (m != m_end || (metric_i != tmap.metrics_end() &&
1986  (*metric_i)->frame() < tend)) {
1987  MetricSection* metric = (metric_i != tmap.metrics_end())
1988  ? *metric_i : NULL;
1989  if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1990  const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1991  LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1992  lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1993  ++m;
1994  } else {
1995  tmetric.set_metric(metric);
1996  bbt = metric->start();
1997  write_position(&_impl->forge, _ev_buffers[port_index],
1998  tmetric, bbt, _session.transport_speed(),
1999  metric->frame(),
2000  metric->frame() - _session.transport_frame());
2001  ++metric_i;
2002  }
2003  }
2004  } else if (!valid) {
2005  // Nothing we understand or care about, connect to scratch
2006  // see note for midi-buffer size above
2007  scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2008  0, _port_minimumSize[port_index]);
2009  _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2010  (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2011  }
2012 
2013  buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2014  } else {
2015  continue; // Control port, leave buffer alone
2016  }
2017  lilv_instance_connect_port(_impl->instance, port_index, buf);
2018  }
2019 
2020  // Read messages from UI and push into appropriate buffers
2021  if (_from_ui) {
2022  uint32_t read_space = _from_ui->read_space();
2023  while (read_space > sizeof(UIMessage)) {
2024  UIMessage msg;
2025  if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2026  error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2027  break;
2028  }
2029  vector<uint8_t> body(msg.size);
2030  if (_from_ui->read(&body[0], msg.size) != msg.size) {
2031  error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2032  break;
2033  }
2034  if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2035  LV2_Evbuf* buf = _ev_buffers[msg.index];
2036  LV2_Evbuf_Iterator i = lv2_evbuf_end(buf);
2037  const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2038  if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2039  (const uint8_t*)(atom + 1))) {
2040  error << "Failed to write data to LV2 event buffer\n";
2041  }
2042  } else {
2043  error << "Received unknown message type from UI" << endmsg;
2044  }
2045  read_space -= sizeof(UIMessage) + msg.size;
2046  }
2047  }
2048 
2049  run(nframes);
2050 
2051  midi_out_index = 0;
2052  for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2053  PortFlags flags = _port_flags[port_index];
2054  bool valid = false;
2055 
2056  /* TODO ask drobilla about comment
2057  * "Make Ardour event buffers generic so plugins can communicate"
2058  * in libs/ardour/buffer_set.cc:310
2059  *
2060  * ideally the user could choose which of the following two modes
2061  * to use (e.g. instrument/effect chains MIDI OUT vs MIDI TRHU).
2062  *
2063  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2064  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2065  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2066  * for quite a while at least ;)
2067  */
2068  // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2069  if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2070  const uint32_t buf_index = out_map.get(
2071  DataType::MIDI, midi_out_index++, &valid);
2072  if (valid) {
2073  bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2074  }
2075  }
2076  // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2077  else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2078  const uint32_t buf_index = out_map.get(
2079  DataType::MIDI, midi_out_index++, &valid);
2080  if (valid) {
2081  bufs.flush_lv2_midi(true, buf_index);
2082  }
2083  }
2084 
2085 
2086  // Write messages to UI
2087  if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2088  (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2089  LV2_Evbuf* buf = _ev_buffers[port_index];
2090  for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2091  lv2_evbuf_is_valid(i);
2092  i = lv2_evbuf_next(i)) {
2093  uint32_t frames, subframes, type, size;
2094  uint8_t* data;
2095  lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2096 
2097  // Intercept patch change messages to emit PropertyChanged signal
2098  if ((flags & PORT_PATCHMSG)) {
2099  LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2100  if (atom->type == _uri_map.urids.atom_Blank ||
2101  atom->type == _uri_map.urids.atom_Object) {
2102  LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2103  if (obj->body.otype == _uri_map.urids.patch_Set) {
2104  const LV2_Atom* property = NULL;
2105  const LV2_Atom* value = NULL;
2106  lv2_atom_object_get(obj,
2107  _uri_map.urids.patch_property, &property,
2108  _uri_map.urids.patch_value, &value,
2109  0);
2110 
2111  if (!property || !value ||
2112  property->type != _uri_map.urids.atom_URID ||
2113  value->type != _uri_map.urids.atom_Path) {
2114  std::cerr << "warning: patch:Set for unknown property" << std::endl;
2115  continue;
2116  }
2117 
2118  const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2119  const char* path = (const char*)LV2_ATOM_BODY_CONST(value);
2120 
2121  // Emit PropertyChanged signal for UI
2122  // TODO: This should emit the control's Changed signal
2123  PropertyChanged(prop_id, Variant(Variant::PATH, path));
2124  }
2125  }
2126  }
2127 
2128  if (!_to_ui) continue;
2129  write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2130  size + sizeof(LV2_Atom),
2131  data - sizeof(LV2_Atom));
2132  }
2133  }
2134  }
2135 
2136  cycles_t now = get_cycles();
2137  set_cycles((uint32_t)(now - then));
2138 
2139  // Update expected transport information for next cycle so we can detect changes
2140  _next_cycle_speed = _session.transport_speed();
2141  _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2142 
2143  return 0;
2144 }
2145 
2146 bool
2147 LV2Plugin::parameter_is_control(uint32_t param) const
2148 {
2149  assert(param < _port_flags.size());
2150  return _port_flags[param] & PORT_CONTROL;
2151 }
2152 
2153 bool
2154 LV2Plugin::parameter_is_audio(uint32_t param) const
2155 {
2156  assert(param < _port_flags.size());
2157  return _port_flags[param] & PORT_AUDIO;
2158 }
2159 
2160 bool
2161 LV2Plugin::parameter_is_event(uint32_t param) const
2162 {
2163  assert(param < _port_flags.size());
2164  return _port_flags[param] & PORT_EVENT;
2165 }
2166 
2167 bool
2168 LV2Plugin::parameter_is_output(uint32_t param) const
2169 {
2170  assert(param < _port_flags.size());
2171  return _port_flags[param] & PORT_OUTPUT;
2172 }
2173 
2174 bool
2175 LV2Plugin::parameter_is_input(uint32_t param) const
2176 {
2177  assert(param < _port_flags.size());
2178  return _port_flags[param] & PORT_INPUT;
2179 }
2180 
2181 void
2182 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2183 {
2184  if (buf && len) {
2185  if (param < parameter_count()) {
2186  snprintf(buf, len, "%.3f", get_parameter(param));
2187  } else {
2188  strcat(buf, "0");
2189  }
2190  }
2191 }
2192 
2193 boost::shared_ptr<ScalePoints>
2194 LV2Plugin::get_scale_points(uint32_t port_index) const
2195 {
2196  const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2197  LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2198 
2199  boost::shared_ptr<ScalePoints> ret;
2200  if (!points) {
2201  return ret;
2202  }
2203 
2204  ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2205 
2206  LILV_FOREACH(scale_points, i, points) {
2207  const LilvScalePoint* p = lilv_scale_points_get(points, i);
2208  const LilvNode* label = lilv_scale_point_get_label(p);
2209  const LilvNode* value = lilv_scale_point_get_value(p);
2210  if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2211  ret->insert(make_pair(lilv_node_as_string(label),
2212  lilv_node_as_float(value)));
2213  }
2214  }
2215 
2216  lilv_scale_points_free(points);
2217  return ret;
2218 }
2219 
2220 void
2221 LV2Plugin::run(pframes_t nframes)
2222 {
2223  uint32_t const N = parameter_count();
2224  for (uint32_t i = 0; i < N; ++i) {
2225  if (parameter_is_control(i) && parameter_is_input(i)) {
2226  _control_data[i] = _shadow_data[i];
2227  }
2228  }
2229 
2230  lilv_instance_run(_impl->instance, nframes);
2231 
2232  if (_impl->work_iface) {
2233  _worker->emit_responses();
2234  if (_impl->work_iface->end_run) {
2235  _impl->work_iface->end_run(_impl->instance->lv2_handle);
2236  }
2237  }
2238 }
2239 
2240 void
2241 LV2Plugin::latency_compute_run()
2242 {
2243  if (!_latency_control_port) {
2244  return;
2245  }
2246 
2247  // Run the plugin so that it can set its latency parameter
2248 
2249  bool was_activated = _was_activated;
2250  activate();
2251 
2252  uint32_t port_index = 0;
2253  uint32_t in_index = 0;
2254  uint32_t out_index = 0;
2255 
2256  // this is done in the main thread. non realtime.
2257  const framecnt_t bufsize = _engine.samples_per_cycle();
2258  float *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2259 
2260  memset(buffer, 0, sizeof(float) * bufsize);
2261 
2262  // FIXME: Ensure plugins can handle in-place processing
2263 
2264  port_index = 0;
2265 
2266  while (port_index < parameter_count()) {
2267  if (parameter_is_audio(port_index)) {
2268  if (parameter_is_input(port_index)) {
2269  lilv_instance_connect_port(_impl->instance, port_index, buffer);
2270  in_index++;
2271  } else if (parameter_is_output(port_index)) {
2272  lilv_instance_connect_port(_impl->instance, port_index, buffer);
2273  out_index++;
2274  }
2275  }
2276  port_index++;
2277  }
2278 
2279  run(bufsize);
2280  deactivate();
2281  if (was_activated) {
2282  activate();
2283  }
2284  free(buffer);
2285 }
2286 
2287 const LilvPort*
2288 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2289 {
2290  const LilvPort* port = NULL;
2291  LilvNode* designation = lilv_new_uri(_world.world, uri);
2292  port = lilv_plugin_get_port_by_designation(
2293  plugin, _world.lv2_InputPort, designation);
2294  lilv_node_free(designation);
2295  if (port) {
2296  bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2297  }
2298  return port;
2299 }
2300 
2301 static bool lv2_filter (const string& str, void* /*arg*/)
2302 {
2303  /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2304 
2305  return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2306 }
2307 
2308 
2309 LV2World::LV2World()
2310  : world(lilv_world_new())
2311  , _bundle_checked(false)
2312 {
2313  atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort);
2314  atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk);
2315  atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence);
2316  atom_bufferType = lilv_new_uri(world, LV2_ATOM__bufferType);
2317  atom_supports = lilv_new_uri(world, LV2_ATOM__supports);
2318  atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2319  ev_EventPort = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2320  ext_logarithmic = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2321  ext_notOnGUI = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2322  lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2323  lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2324  lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2325  lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2326  lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2327  lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
2328  lv2_default = lilv_new_uri(world, LV2_CORE__default);
2329  lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
2330  lv2_maximum = lilv_new_uri(world, LV2_CORE__maximum);
2331  lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2332  lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
2333  lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
2334  lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
2335  lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
2336  midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2337  rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");
2338  rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label");
2339  rdfs_range = lilv_new_uri(world, LILV_NS_RDFS "range");
2340  rsz_minimumSize = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2341  time_Position = lilv_new_uri(world, LV2_TIME__Position);
2342  ui_GtkUI = lilv_new_uri(world, LV2_UI__GtkUI);
2343  ui_external = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2344  ui_externalkx = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2345  units_unit = lilv_new_uri(world, LV2_UNITS__unit);
2346  units_render = lilv_new_uri(world, LV2_UNITS__render);
2347  units_hz = lilv_new_uri(world, LV2_UNITS__hz);
2348  units_midiNote = lilv_new_uri(world, LV2_UNITS__midiNote);
2349  units_db = lilv_new_uri(world, LV2_UNITS__db);
2350  patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
2351  patch_Message = lilv_new_uri(world, LV2_PATCH__Message);
2352 }
2353 
2354 LV2World::~LV2World()
2355 {
2356  lilv_node_free(patch_Message);
2357  lilv_node_free(patch_writable);
2358  lilv_node_free(units_hz);
2359  lilv_node_free(units_midiNote);
2360  lilv_node_free(units_db);
2361  lilv_node_free(units_unit);
2362  lilv_node_free(units_render);
2363  lilv_node_free(ui_externalkx);
2364  lilv_node_free(ui_external);
2365  lilv_node_free(ui_GtkUI);
2366  lilv_node_free(time_Position);
2367  lilv_node_free(rsz_minimumSize);
2368  lilv_node_free(rdfs_comment);
2369  lilv_node_free(rdfs_label);
2370  lilv_node_free(rdfs_range);
2371  lilv_node_free(midi_MidiEvent);
2372  lilv_node_free(lv2_enumeration);
2373  lilv_node_free(lv2_freewheeling);
2374  lilv_node_free(lv2_toggled);
2375  lilv_node_free(lv2_sampleRate);
2376  lilv_node_free(lv2_reportsLatency);
2377  lilv_node_free(lv2_integer);
2378  lilv_node_free(lv2_inPlaceBroken);
2379  lilv_node_free(lv2_OutputPort);
2380  lilv_node_free(lv2_InputPort);
2381  lilv_node_free(lv2_ControlPort);
2382  lilv_node_free(lv2_AudioPort);
2383  lilv_node_free(ext_notOnGUI);
2384  lilv_node_free(ext_logarithmic);
2385  lilv_node_free(ev_EventPort);
2386  lilv_node_free(atom_supports);
2387  lilv_node_free(atom_eventTransfer);
2388  lilv_node_free(atom_bufferType);
2389  lilv_node_free(atom_Sequence);
2390  lilv_node_free(atom_Chunk);
2391  lilv_node_free(atom_AtomPort);
2392  lilv_world_free(world);
2393 }
2394 
2395 void
2396 LV2World::load_bundled_plugins(bool verbose)
2397 {
2398  if (!_bundle_checked) {
2399  if (verbose) {
2400  cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2401  }
2402 
2403  vector<string> plugin_objects;
2404  find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2405  for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2406 #ifdef PLATFORM_WINDOWS
2407  string uri = "file:///" + *x + "/";
2408 #else
2409  string uri = "file://" + *x + "/";
2410 #endif
2411  LilvNode *node = lilv_new_uri(world, uri.c_str());
2412  lilv_world_load_bundle(world, node);
2413  lilv_node_free(node);
2414  }
2415 
2416  lilv_world_load_all(world);
2417  _bundle_checked = true;
2418  }
2419 }
2420 
2421 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2422 {
2423  type = ARDOUR::LV2;
2424  _plugin_uri = strdup(plugin_uri);
2425 }
2426 
2427 LV2PluginInfo::~LV2PluginInfo()
2428 {
2429  free(_plugin_uri);
2430  _plugin_uri = NULL;
2431 }
2432 
2433 PluginPtr
2434 LV2PluginInfo::load(Session& session)
2435 {
2436  try {
2437  PluginPtr plugin;
2438  const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2439  LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2440  if (!uri) { throw failed_constructor(); }
2441  const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2442  if (!lp) { throw failed_constructor(); }
2443  plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2444  lilv_node_free(uri);
2445  plugin->set_info(PluginInfoPtr(shared_from_this ()));
2446  return plugin;
2447  } catch (failed_constructor& err) {
2448  return PluginPtr((Plugin*)0);
2449  }
2450 
2451  return PluginPtr();
2452 }
2453 
2454 PluginInfoList*
2455 LV2PluginInfo::discover()
2456 {
2457  LV2World world;
2458  world.load_bundled_plugins();
2459  _world.load_bundled_plugins(true);
2460 
2461  PluginInfoList* plugs = new PluginInfoList;
2462  const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2463 
2464  LILV_FOREACH(plugins, i, plugins) {
2465  const LilvPlugin* p = lilv_plugins_get(plugins, i);
2466  const LilvNode* pun = lilv_plugin_get_uri(p);
2467  if (!pun) continue;
2468  LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2469 
2470  LilvNode* name = lilv_plugin_get_name(p);
2471  if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2472  warning << "Ignoring invalid LV2 plugin "
2473  << lilv_node_as_string(lilv_plugin_get_uri(p))
2474  << endmsg;
2475  continue;
2476  }
2477 
2478  info->type = LV2;
2479 
2480  info->name = string(lilv_node_as_string(name));
2481  lilv_node_free(name);
2482  ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2483 
2484  const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2485  const LilvNode* label = lilv_plugin_class_get_label(pclass);
2486  info->category = lilv_node_as_string(label);
2487 
2488  LilvNode* author_name = lilv_plugin_get_author_name(p);
2489  info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2490  lilv_node_free(author_name);
2491 
2492  info->path = "/NOPATH"; // Meaningless for LV2
2493 
2494  /* count atom-event-ports that feature
2495  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2496  *
2497  * TODO: nicely ask drobilla to make a lilv_ call for that
2498  */
2499  int count_midi_out = 0;
2500  int count_midi_in = 0;
2501  for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2502  const LilvPort* port = lilv_plugin_get_port_by_index(p, i);
2503  if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2504  LilvNodes* buffer_types = lilv_port_get_value(
2505  p, port, world.atom_bufferType);
2506  LilvNodes* atom_supports = lilv_port_get_value(
2507  p, port, world.atom_supports);
2508 
2509  if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2510  && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2511  if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2512  count_midi_in++;
2513  }
2514  if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2515  count_midi_out++;
2516  }
2517  }
2518  lilv_nodes_free(buffer_types);
2519  lilv_nodes_free(atom_supports);
2520  }
2521  }
2522 
2523  info->n_inputs.set_audio(
2524  lilv_plugin_get_num_ports_of_class(
2525  p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2526  info->n_inputs.set_midi(
2527  lilv_plugin_get_num_ports_of_class(
2528  p, world.lv2_InputPort, world.ev_EventPort, NULL)
2529  + count_midi_in);
2530 
2531  info->n_outputs.set_audio(
2532  lilv_plugin_get_num_ports_of_class(
2533  p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2534  info->n_outputs.set_midi(
2535  lilv_plugin_get_num_ports_of_class(
2536  p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2537  + count_midi_out);
2538 
2539  info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2540  info->index = 0; // Meaningless for LV2
2541 
2542  plugs->push_back(info);
2543  }
2544 
2545  return plugs;
2546 }
ui
static ARDOUR_UI * ui
Definition: main.cc:76
ARDOUR::LV2Plugin::PORT_SEQUENCE
New atom API event port.
Definition: lv2_plugin.h:193
PBD::find_paths_matching_filter
void find_paths_matching_filter(vector< string > &result, const Searchpath &paths, bool(*filter)(const string &, void *), void *arg, bool pass_fullpath, bool return_fullpath, bool recurse)
Definition: file_utils.cc:260
lv2_evbuf_is_valid
bool lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter)
Definition: lv2_evbuf.c:152
LV2World::units_render
LilvNode * units_render
Definition: lv2_plugin.cc:154
LV2_ATOM_BODY_CONST
#define LV2_ATOM_BODY_CONST(atom)
Definition: lv2_plugin.cc:88
ARDOUR::LV2Plugin::_worker
Worker * _worker
Definition: lv2_plugin.h:165
ARDOUR::Worker::respond
bool respond(uint32_t size, const void *data)
Definition: worker.cc:64
lv2_evbuf_begin
LV2_Evbuf_Iterator lv2_evbuf_begin(LV2_Evbuf *evbuf)
Definition: lv2_evbuf.c:137
ARDOUR::LV2Plugin::PORT_MIDI
Event port understands MIDI.
Definition: lv2_plugin.h:194
LV2World::ui_external
LilvNode * ui_external
Definition: lv2_plugin.cc:149
ARDOUR::LV2Plugin::load_preset
bool load_preset(PresetRecord)
Definition: lv2_plugin.cc:1033
ARDOUR::LV2Plugin::parameter_is_output
bool parameter_is_output(uint32_t) const
Definition: lv2_plugin.cc:2168
LV2World::units_db
LilvNode * units_db
Definition: lv2_plugin.cc:152
LV2World::world
LilvWorld * world
Definition: lv2_plugin.cc:117
ARDOUR::Variant::PATH
File path string.
Definition: variant.h:47
ARDOUR::LV2Plugin::_patch_port_out_index
uint32_t _patch_port_out_index
Definition: lv2_plugin.h:179
ARDOUR::LV2Plugin::_control_data
float * _control_data
Definition: lv2_plugin.h:167
LV2World::units_hz
LilvNode * units_hz
Definition: lv2_plugin.cc:151
ARDOUR::URIMap::URIDs::time_beatsPerBar
uint32_t time_beatsPerBar
Definition: uri_map.h:78
ARDOUR::URIMap::URIDs::atom_eventTransfer
uint32_t atom_eventTransfer
Definition: uri_map.h:65
ARDOUR::Plugin::set_state
virtual int set_state(const XMLNode &, int version)
Definition: plugin.cc:369
ARDOUR::LV2Plugin::_insert_id
PBD::ID _insert_id
Definition: lv2_plugin.h:177
Evoral::ParameterDescriptor::lower
float lower
Minimum value (in Hz, for frequencies)
Definition: ParameterDescriptor.hpp:35
ARDOUR::BufferSet::get_midi
MidiBuffer & get_midi(size_t i)
Definition: buffer_set.h:107
ARDOUR::LV2Plugin::name
const char * name() const
Definition: lv2_plugin.cc:701
ARDOUR::LV2Plugin::Impl::forge
LV2_Atom_Forge forge
Definition: lv2_plugin.cc:253
log_printf
static int log_printf(LV2_Log_Handle handle, LV2_URID type, const char *fmt,...)
Definition: lv2_plugin.cc:223
ARDOUR::LV2Plugin::is_external_ui
bool is_external_ui() const
Definition: lv2_plugin.cc:645
ARDOUR::URIMap::URIDs::patch_Get
uint32_t patch_Get
Definition: uri_map.h:82
LV2World::lv2_maximum
LilvNode * lv2_maximum
Definition: lv2_plugin.cc:138
ARDOUR::LV2Plugin::default_value
float default_value(uint32_t port)
Definition: lv2_plugin.cc:725
ARDOUR::LV2Plugin::_next_cycle_start
framepos_t _next_cycle_start
Expected start frame of next run cycle.
Definition: lv2_plugin.h:175
RingBuffer::read_space
guint read_space() const
Definition: ringbuffer.h:97
ARDOUR::TempoMap::bbt_time
void bbt_time(framepos_t when, Timecode::BBT_Time &)
Definition: tempo.cc:1168
ARDOUR::LV2Plugin::latency_compute_run
void latency_compute_run()
Definition: lv2_plugin.cc:2241
XMLProperty::value
const std::string & value() const
Definition: xml++.h:159
ARDOUR::MidiBuffer::iterator_base
Definition: midi_buffer.h:65
ARDOUR::LV2Plugin::LV2Plugin
LV2Plugin(ARDOUR::AudioEngine &engine, ARDOUR::Session &session, const void *c_plugin, framecnt_t sample_rate)
Definition: lv2_plugin.cc:257
ARDOUR::LV2Plugin::_options_feature
LV2_Feature _options_feature
Definition: lv2_plugin.h:239
ARDOUR::Variant::URI
URI string.
Definition: variant.h:49
ARDOUR::URIMap::URIDs::time_barBeat
uint32_t time_barBeat
Definition: uri_map.h:76
ARDOUR::TempoMetric::meter
const Meter & meter() const
Definition: tempo.h:196
ARDOUR::legalize_for_uri
LIBARDOUR_API std::string legalize_for_uri(const std::string &str)
ARDOUR::LV2Plugin::_uri_map
URIMap & _uri_map
Definition: lv2_plugin.h:180
ARDOUR::LV2Plugin::get_docs
std::string get_docs() const
Definition: lv2_plugin.cc:788
ARDOUR::URIMap::URIDs::atom_Chunk
uint32_t atom_Chunk
Definition: uri_map.h:62
ARDOUR::Session::transport_speed
double transport_speed() const
Definition: session.h:590
ARDOUR::URIMap::urids
URIDs urids
Definition: uri_map.h:88
uri_to_variant_type
static bool uri_to_variant_type(const std::string &uri, Variant::Type &type)
Definition: lv2_plugin.cc:1286
ARDOUR::LV2Plugin::c_ui_type
const void * c_ui_type()
Definition: lv2_plugin.cc:852
ARDOUR::URIMap::URIDs::atom_Path
uint32_t atom_Path
Definition: uri_map.h:63
LV2World::atom_Sequence
LilvNode * atom_Sequence
Definition: lv2_plugin.cc:121
lv2_filter
static bool lv2_filter(const string &str, void *)
Definition: lv2_plugin.cc:2301
ARDOUR::Plugin::set_parameter
virtual void set_parameter(uint32_t which, float val)
Definition: plugin.cc:361
ARDOUR::LV2Plugin::worker
Worker * worker()
Definition: lv2_plugin.h:147
lv2_evbuf_end
LV2_Evbuf_Iterator lv2_evbuf_end(LV2_Evbuf *evbuf)
Definition: lv2_evbuf.c:144
ARDOUR::URIMap::urid_map_feature
LV2_Feature * urid_map_feature()
Definition: uri_map.h:49
ARDOUR::LV2Plugin::run
void run(pframes_t nsamples)
Definition: lv2_plugin.cc:2221
ARDOUR::URIMap::urid_map
LV2_URID_Map * urid_map()
Definition: uri_map.h:52
LV2World::patch_writable
LilvNode * patch_writable
Definition: lv2_plugin.cc:156
search_paths.h
ARDOUR::AudioEngine::samples_per_cycle
pframes_t samples_per_cycle() const
Definition: audioengine.cc:983
ARDOUR::LV2Plugin::PORT_AUDIO
Audio (buffer of float)
Definition: lv2_plugin.h:190
ARDOUR::LV2Plugin::set_insert_id
void set_insert_id(PBD::ID id)
Definition: lv2_plugin.cc:1540
ARDOUR::LV2Plugin::num_ports
uint32_t num_ports() const
Definition: lv2_plugin.cc:713
ARDOUR::LV2Plugin::_ev_buffers
LV2_Evbuf ** _ev_buffers
Definition: lv2_plugin.h:170
ARDOUR::TempoMetric::set_metric
void set_metric(const MetricSection *section)
Definition: tempo.h:183
LV2_Evbuf_Impl
Definition: lv2_evbuf.c:26
PBD::remove_directory
void remove_directory(const std::string &dir)
Definition: file_utils.cc:465
ARDOUR::Worker::emit_responses
void emit_responses()
Definition: worker.cc:102
ARDOUR::LV2Plugin::Impl::plugin
const LilvPlugin * plugin
Definition: lv2_plugin.cc:245
XMLNode::name
const std::string & name() const
Definition: xml++.h:104
LV2World::rsz_minimumSize
LilvNode * rsz_minimumSize
Definition: lv2_plugin.cc:146
work_respond
static LV2_Worker_Status work_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void *data)
Definition: lv2_plugin.cc:186
LV2World::ext_notOnGUI
LilvNode * ext_notOnGUI
Definition: lv2_plugin.cc:127
lv2_plugin.h
ARDOUR::ScalePoints
std::map< const std::string, const float > ScalePoints
Definition: parameter_descriptor.h:30
load_parameter_descriptor_units
static void load_parameter_descriptor_units(LilvWorld *lworld, ParameterDescriptor &desc, const LilvNodes *units)
Definition: lv2_plugin.cc:1362
ARDOUR::TempoMap::metrics_end
Metrics::const_iterator metrics_end()
Definition: tempo.h:320
ARDOUR::Session::tempo_map
TempoMap & tempo_map()
Definition: session.h:596
ARDOUR::URIMap::URIDs::time_frame
uint32_t time_frame
Definition: uri_map.h:80
ARDOUR::LV2Plugin::_make_path_feature
LV2_Feature _make_path_feature
Definition: lv2_plugin.h:236
ARDOUR::LV2Plugin::signal_latency
framecnt_t signal_latency() const
Definition: lv2_plugin.cc:1703
ARDOUR::LV2Plugin::Impl::ui_forge
LV2_Atom_Forge ui_forge
Definition: lv2_plugin.cc:254
LV2World::atom_bufferType
LilvNode * atom_bufferType
Definition: lv2_plugin.cc:122
ARDOUR::Plugin::_engine
ARDOUR::AudioEngine & _engine
Definition: plugin.h:285
N
static int N
Definition: signals_test.cc:27
ARDOUR::pframes_t
uint32_t pframes_t
Definition: types.h:61
load_parameter_descriptor
static void load_parameter_descriptor(LV2World &world, ParameterDescriptor &desc, Variant::Type datatype, const LilvNode *subject)
Definition: lv2_plugin.cc:1382
ARDOUR::URIMap::URIDs::atom_Object
uint32_t atom_Object
Definition: uri_map.h:68
ARDOUR::LV2Plugin::write_to_ui
bool write_to_ui(uint32_t index, uint32_t protocol, uint32_t size, const uint8_t *body)
Definition: lv2_plugin.cc:1232
_world
static LV2World _world
Definition: lv2_plugin.cc:163
std
Definition: Beats.hpp:239
PBD::error
LIBPBD_API Transmitter error
PBD::warning
LIBPBD_API Transmitter warning
LV2World::lv2_integer
LilvNode * lv2_integer
Definition: lv2_plugin.cc:135
XMLNode::children
const XMLNodeList & children(const std::string &str=std::string()) const
Definition: xml++.cc:329
ARDOUR::LV2Plugin::allocate_atom_event_buffers
void allocate_atom_event_buffers()
Definition: lv2_plugin.cc:1765
ARDOUR::ParameterDescriptor::key
uint32_t key
for properties
Definition: parameter_descriptor.h:55
endmsg
std::ostream & endmsg(std::ostream &ostr)
Definition: transmitter.h:71
ARDOUR::LV2PluginInfo::discover
static PluginInfoList * discover()
Definition: lv2_plugin.cc:2455
ARDOUR::Variant::FLOAT
C float (32-bit IEEE-754)
Definition: variant.h:44
ARDOUR::URIMap::URIDs::time_speed
uint32_t time_speed
Definition: uri_map.h:81
ARDOUR::URIMap::instance
static URIMap & instance()
Definition: uri_map.cc:66
ARDOUR::LV2Plugin::Impl::ui_type
const LilvNode * ui_type
Definition: lv2_plugin.cc:247
ARDOUR::LV2Plugin::_bpm_control_port
float * _bpm_control_port
Special input set by ardour.
Definition: lv2_plugin.h:172
lv2_evbuf_get_buffer
void * lv2_evbuf_get_buffer(LV2_Evbuf *evbuf)
Definition: lv2_evbuf.c:125
ARDOUR::Session::frame_rate
framecnt_t frame_rate() const
Definition: session.h:365
RingBuffer::read
guint read(T *dest, guint cnt)
Definition: ringbuffer.h:124
ARDOUR::BufferSet::get_audio
AudioBuffer & get_audio(size_t i)
Definition: buffer_set.h:100
ARDOUR::LV2Plugin::file_dir
const std::string file_dir() const
Definition: lv2_plugin.cc:873
ARDOUR::LV2Plugin::port_index
uint32_t port_index(const char *symbol) const
Definition: lv2_plugin.cc:743
ARDOUR::LV2Plugin::maker
const char * maker() const
Definition: lv2_plugin.cc:707
get_cycles
static cycles_t get_cycles(void)
Definition: cycles.h:230
ARDOUR::LV2Plugin::_data_access_extension_data
LV2_DataAccess _data_access_extension_data
Definition: lv2_plugin.h:233
ARDOUR::ChanCount::n_midi
uint32_t n_midi() const
Definition: chan_count.h:66
ARDOUR::LV2Plugin::_log_feature
LV2_Feature _log_feature
Definition: lv2_plugin.h:237
LV2World::atom_eventTransfer
LilvNode * atom_eventTransfer
Definition: lv2_plugin.cc:123
ARDOUR::LV2Plugin::plugin_dir
const std::string plugin_dir() const
Definition: lv2_plugin.cc:859
PBD::ID
Definition: id.h:32
ARDOUR::LV2Plugin::lv2_state_make_path
static char * lv2_state_make_path(void *host_data, const char *path)
Definition: lv2_plugin.cc:889
LV2World::ext_logarithmic
LilvNode * ext_logarithmic
Definition: lv2_plugin.cc:126
LV2World::lv2_inPlaceBroken
LilvNode * lv2_inPlaceBroken
Definition: lv2_plugin.cc:134
ARDOUR::Plugin::connect_and_run
virtual int connect_and_run(BufferSet &bufs, ChanMapping in, ChanMapping out, pframes_t nframes, framecnt_t offset)
Definition: plugin.cc:259
ARDOUR::Variant::get_bool
bool get_bool() const
Definition: variant.h:118
ARDOUR::LV2Plugin::_port_flags
std::vector< PortFlags > _port_flags
Definition: lv2_plugin.h:201
LV2World::lv2_InputPort
LilvNode * lv2_InputPort
Definition: lv2_plugin.cc:130
lv2_evbuf_get
bool lv2_evbuf_get(LV2_Evbuf_Iterator iter, uint32_t *frames, uint32_t *subframes, uint32_t *type, uint32_t *size, uint8_t **data)
Definition: lv2_evbuf.c:185
LV2World::units_unit
LilvNode * units_unit
Definition: lv2_plugin.cc:153
ARDOUR::LV2Plugin::parameter_count
uint32_t parameter_count() const
Definition: lv2_plugin.cc:719
XMLNodeList
std::list< XMLNode * > XMLNodeList
Definition: xml++.h:44
ARDOUR::MetricSection::start
const Timecode::BBT_Time & start() const
Definition: tempo.h:99
lv2_evbuf_next
LV2_Evbuf_Iterator lv2_evbuf_next(LV2_Evbuf_Iterator iter)
Definition: lv2_evbuf.c:158
forge_variant
static void forge_variant(LV2_Atom_Forge *forge, const Variant &value)
Definition: lv2_plugin.cc:1245
_
#define _(Text)
Definition: i18n.h:11
boost::shared_ptr< ScalePoints >
ARDOUR::URIMap::uri_to_id
uint32_t uri_to_id(const char *uri)
Definition: uri_map.cc:133
ARDOUR::Plugin::preset_by_label
const PresetRecord * preset_by_label(const std::string &)
Definition: plugin.cc:235
ARDOUR::Worker::schedule
bool schedule(uint32_t size, const void *data)
Definition: worker.cc:48
ARDOUR::LV2Plugin::parameter_is_input
bool parameter_is_input(uint32_t) const
Definition: lv2_plugin.cc:2175
ARDOUR::LV2Plugin::extension_data
const void * extension_data(const char *uri) const
Definition: lv2_plugin.cc:834
ARDOUR::LV2Plugin::set_parameter
void set_parameter(uint32_t port, float val)
Definition: lv2_plugin.cc:755
ARDOUR::URIMap::urid_unmap
LV2_URID_Unmap * urid_unmap()
Definition: uri_map.h:53
ARDOUR::Variant::get_uri
const std::string & get_uri() const
Definition: variant.h:138
ARDOUR::URIMap::URIDs::time_bar
uint32_t time_bar
Definition: uri_map.h:75
lv2_evbuf_write
bool lv2_evbuf_write(LV2_Evbuf_Iterator *iter, uint32_t frames, uint32_t subframes, uint32_t type, uint32_t size, const uint8_t *data)
Definition: lv2_evbuf.c:230
ARDOUR::LV2Plugin::PORT_EVENT
Old event API event port.
Definition: lv2_plugin.h:192
ARDOUR::PluginPtr
boost::shared_ptr< Plugin > PluginPtr
Definition: plugin.h:50
PATH_MAX
#define PATH_MAX
Definition: lv2_plugin.h:34
lv2_evbuf_new
LV2_Evbuf * lv2_evbuf_new(uint32_t capacity, LV2_Evbuf_Type type, uint32_t atom_Chunk, uint32_t atom_Sequence)
Definition: lv2_evbuf.c:44
X_
#define X_(Text)
Definition: i18n.h:13
stl_delete.h
ARDOUR::framecnt_t
int64_t framecnt_t
Definition: types.h:76
XMLNode::property
XMLProperty * property(const char *)
Definition: xml++.cc:413
ARDOUR::LV2Plugin::_def_state_feature
LV2_Feature _def_state_feature
Definition: lv2_plugin.h:240
Evoral::ParameterDescriptor::upper
float upper
Maximum value (in Hz, for frequencies)
Definition: ParameterDescriptor.hpp:36
ARDOUR::LV2Plugin::get_parameter
float get_parameter(uint32_t port) const
Definition: lv2_plugin.cc:777
ARDOUR::LV2Plugin::label
const char * label() const
Definition: lv2_plugin.cc:695
ARDOUR::LV2Plugin::_block_length
int32_t _block_length
Definition: lv2_plugin.h:243
LV2World::ev_EventPort
LilvNode * ev_EventPort
Definition: lv2_plugin.cc:125
Evoral::Event::size
uint32_t size() const
Definition: Event.hpp:134
ARDOUR::LV2Plugin::Impl::work_iface
const LV2_Worker_Interface * work_iface
Definition: lv2_plugin.cc:251
LV2World::units_midiNote
LilvNode * units_midiNote
Definition: lv2_plugin.cc:155
ARDOUR::URIMap::URIDs::time_beatUnit
uint32_t time_beatUnit
Definition: uri_map.h:77
ARDOUR::Plugin::get_property_descriptor
virtual const ParameterDescriptor & get_property_descriptor(uint32_t id) const
Definition: plugin.h:249
ARDOUR::LV2Plugin::_shadow_data
float * _shadow_data
Definition: lv2_plugin.h:168
ARDOUR::Plugin::PropertyDescriptors
std::map< uint32_t, ParameterDescriptor > PropertyDescriptors
Definition: plugin.h:234
ARDOUR::LV2Plugin::scratch_dir
const std::string scratch_dir() const
Definition: lv2_plugin.cc:866
lv2_evbuf_get_capacity
uint32_t lv2_evbuf_get_capacity(LV2_Evbuf *evbuf)
Definition: lv2_evbuf.c:119
ARDOUR::LV2Plugin::_work_schedule_feature
LV2_Feature _work_schedule_feature
Definition: lv2_plugin.h:238
LV2_EVBUF_ATOM
Definition: lv2_evbuf.h:40
ARDOUR::LV2Plugin::ui_is_resizable
bool ui_is_resizable() const
Definition: lv2_plugin.cc:663
ARDOUR::Session::transport_frame
framepos_t transport_frame() const
Definition: session.h:551
ARDOUR
Definition: amp.h:29
ARDOUR::LV2Plugin::c_ui
const void * c_ui()
Definition: lv2_plugin.cc:846
LV2_PATCH__writable
#define LV2_PATCH__writable
Definition: lv2_plugin.cc:97
LV2World::rdfs_range
LilvNode * rdfs_range
Definition: lv2_plugin.cc:145
ARDOUR::Variant::get_float
float get_float() const
Definition: variant.h:120
ARDOUR::ParameterDescriptor::print_fmt
std::string print_fmt
format string for pretty printing
Definition: parameter_descriptor.h:53
ARDOUR::Session::plugins_dir
std::string plugins_dir() const
Plugin state.
Definition: session_state.cc:2254
ARDOUR::Plugin::_presets
std::map< std::string, PresetRecord > _presets
Definition: plugin.h:289
ARDOUR::URIMap::uri_map_feature
LV2_Feature * uri_map_feature()
Definition: uri_map.h:48
PBD::Stateful::id
const PBD::ID & id() const
Definition: stateful.h:68
ARDOUR::LV2Plugin::work
int work(uint32_t size, const void *data)
Definition: lv2_plugin.cc:1526
PBD::ID::to_s
std::string to_s() const
Definition: id.cc:78
ARDOUR::LV2Plugin::parameter_is_control
bool parameter_is_control(uint32_t) const
Definition: lv2_plugin.cc:2147
ARDOUR::LV2Plugin::work_response
int work_response(uint32_t size, const void *data)
Definition: lv2_plugin.cc:1533
file_utils.h
LV2World::lv2_toggled
LilvNode * lv2_toggled
Definition: lv2_plugin.cc:141
LV2World::ui_GtkUI
LilvNode * ui_GtkUI
Definition: lv2_plugin.cc:148
LV2World::midi_MidiEvent
LilvNode * midi_MidiEvent
Definition: lv2_plugin.cc:142
Evoral::Event::time
Time time() const
Definition: Event.hpp:132
ARDOUR::LV2Plugin::describe_parameter
std::string describe_parameter(Evoral::Parameter)
Definition: lv2_plugin.cc:1673
ARDOUR::LV2Plugin::parameter_is_event
bool parameter_is_event(uint32_t) const
Definition: lv2_plugin.cc:2161
ARDOUR::Variant::LONG
Signed 64-bit int.
Definition: variant.h:46
ARDOUR::LV2Plugin::PORT_PATCHMSG
Event port supports patch:Message.
Definition: lv2_plugin.h:196
ARDOUR::LV2Plugin::init
void init(const void *c_plugin, framecnt_t rate)
Definition: lv2_plugin.cc:294
LV2World::rdfs_label
LilvNode * rdfs_label
Definition: lv2_plugin.cc:144
DEBUG_TRACE
#define DEBUG_TRACE(bits, str)
Definition: debug.h:55
ARDOUR::framepos_t
int64_t framepos_t
Definition: types.h:66
RingBuffer::write
guint write(T const *src, guint cnt)
Definition: ringbuffer.h:163
LV2World::lv2_enumeration
LilvNode * lv2_enumeration
Definition: lv2_plugin.cc:132
ARDOUR::LV2Plugin::get_scale_points
boost::shared_ptr< ScalePoints > get_scale_points(uint32_t port_index) const
Definition: lv2_plugin.cc:2194
ARDOUR::LV2Plugin::_state_version
unsigned _state_version
Definition: lv2_plugin.h:246
ARDOUR::LV2Plugin::PORT_POSITION
Event port understands position.
Definition: lv2_plugin.h:195
ARDOUR::LV2Plugin::get_property_descriptor
const ParameterDescriptor & get_property_descriptor(uint32_t id) const
Definition: lv2_plugin.cc:1352
ARDOUR::Variant::STRING
Raw string (no semantics)
Definition: variant.h:48
ARDOUR::LV2Plugin::state_node_name
std::string state_node_name() const
Definition: lv2_plugin.h:106
ARDOUR::Meter::note_divisor
double note_divisor() const
Definition: tempo.h:71
PBD::Stateful::properties
const OwnedPropertyList & properties() const
Definition: stateful.h:56
ARDOUR::Variant::get_beats
const Evoral::Beats & get_beats() const
Definition: variant.h:173
ARDOUR::LV2Plugin::UIMessage
Message send to/from UI via ports.
Definition: lv2_plugin.h:208
LV2World::lv2_ControlPort
LilvNode * lv2_ControlPort
Definition: lv2_plugin.cc:129
ARDOUR::Variant::get_path
const std::string & get_path() const
Definition: variant.h:136
PBD::info
LIBPBD_API Transmitter info
ARDOUR::Variant::BEATS
Beats+ticks.
Definition: variant.h:41
ARDOUR::LV2Plugin::connect_and_run
int connect_and_run(BufferSet &bufs, ChanMapping in, ChanMapping out, pframes_t nframes, framecnt_t offset)
Definition: lv2_plugin.cc:1882
ARDOUR::LV2Plugin::unique_id
std::string unique_id() const
Definition: lv2_plugin.cc:683
ARDOUR::LV2Plugin::_to_ui
RingBuffer< uint8_t > * _to_ui
Definition: lv2_plugin.h:226
ARDOUR::LV2Plugin::do_remove_preset
void do_remove_preset(std::string)
Definition: lv2_plugin.cc:1128
ARDOUR::Tempo::beats_per_minute
double beats_per_minute() const
Definition: tempo.h:53
ARDOUR::LV2Plugin::enable_ui_emission
void enable_ui_emission()
Definition: lv2_plugin.cc:1485
PBD::DEBUG::LV2
LIBARDOUR_API uint64_t LV2
Definition: debug.cc:51
ARDOUR::AudioEngine::raw_buffer_size
size_t raw_buffer_size(DataType t)
Definition: audioengine.cc:1001
ARDOUR::LV2Plugin::write_from_ui
bool write_from_ui(uint32_t index, uint32_t protocol, uint32_t size, const uint8_t *body)
Definition: lv2_plugin.cc:1198
ARDOUR::LV2Plugin::_data_access_feature
LV2_Feature _data_access_feature
Definition: lv2_plugin.h:234
ARDOUR::LV2Plugin::uri
const char * uri() const
Definition: lv2_plugin.cc:689
ARDOUR::Variant::get_long
long get_long() const
Definition: variant.h:122
ARDOUR::LV2Plugin::PORT_CONTROL
Control (single float)
Definition: lv2_plugin.h:191
ARDOUR::LV2Plugin::add_state
void add_state(XMLNode *) const
Definition: lv2_plugin.cc:911
ARDOUR::LV2Plugin::state_dir
const std::string state_dir(unsigned num) const
Definition: lv2_plugin.cc:880
LV2World::lv2_freewheeling
LilvNode * lv2_freewheeling
Definition: lv2_plugin.cc:133
XMLNode::add_property
XMLProperty * add_property(const char *name, const std::string &value)
set_port_value
static void set_port_value(const char *port_symbol, void *user_data, const void *value, uint32_t, uint32_t type)
Definition: lv2_plugin.cc:1015
ARDOUR::LV2PluginInfo::LV2PluginInfo
LV2PluginInfo(const char *plugin_uri)
Definition: lv2_plugin.cc:2421
ARDOUR::LV2Plugin::_from_ui
RingBuffer< uint8_t > * _from_ui
Definition: lv2_plugin.h:227
LV2World::atom_Chunk
LilvNode * atom_Chunk
Definition: lv2_plugin.cc:120
ARDOUR::LV2Plugin::PortFlags
unsigned PortFlags
Definition: lv2_plugin.h:199
name
const char * name
Definition: rc_option_editor.cc:257
ARDOUR::Plugin::PropertyChanged
PBD::Signal2< void, uint32_t, Variant > PropertyChanged
Definition: plugin.h:267
ARDOUR::lv2plugin_get_port_value
const void * lv2plugin_get_port_value(const char *port_symbol, void *user_data, uint32_t *size, uint32_t *type)
Definition: lv2_plugin.cc:1050
XMLNode::add_child_nocopy
void add_child_nocopy(XMLNode &)
Definition: xml++.cc:357
ARDOUR::AudioEngine::freewheeling
bool freewheeling() const
Definition: audioengine.h:129
ARDOUR::Variant::INT
Signed 32-bit int.
Definition: variant.h:45
ARDOUR::URIMap::URIDs::atom_URID
uint32_t atom_URID
Definition: uri_map.h:66
Evoral::Parameter::id
uint32_t id() const
Definition: Parameter.hpp:49
ARDOUR::LV2Plugin::announce_property_values
void announce_property_values()
Definition: lv2_plugin.cc:1456
ARDOUR::LV2Plugin::_features
LV2_Feature ** _features
Definition: lv2_plugin.h:164
LV2World::load_bundled_plugins
void load_bundled_plugins(bool verbose=false)
Definition: lv2_plugin.cc:2396
Evoral::ParameterDescriptor::toggled
bool toggled
True iff parameter is boolean.
Definition: ParameterDescriptor.hpp:37
ARDOUR::LV2Plugin::parameter_is_audio
bool parameter_is_audio(uint32_t) const
Definition: lv2_plugin.cc:2154
ARDOUR::Variant::type
Type type() const
Definition: variant.h:177
ARDOUR::URIMap::URIDs::time_Position
uint32_t time_Position
Definition: uri_map.h:74
ARDOUR::LV2Plugin::print_parameter
void print_parameter(uint32_t param, char *buf, uint32_t len) const
Definition: lv2_plugin.cc:2182
ARDOUR::LV2Plugin::load_supported_properties
void load_supported_properties(PropertyDescriptors &descs)
Definition: lv2_plugin.cc:1419
XMLNode
Definition: xml++.h:95
ARDOUR::Properties::position
LIBARDOUR_API PBD::PropertyDescriptor< framepos_t > position
Definition: region.cc:65
ARDOUR::BufferSet::count
const ChanCount & count() const
Definition: buffer_set.h:87
boost::shared_ptr::reset
void reset()
Definition: shared_ptr.hpp:240
ARDOUR::LV2Plugin::_sample_rate
framecnt_t _sample_rate
Definition: lv2_plugin.h:166
ARDOUR::ChanCount::set
void set(DataType t, uint32_t count)
Definition: chan_count.h:58
LV2World::_bundle_checked
bool _bundle_checked
Definition: lv2_plugin.cc:160
PBD::Searchpath::to_string
LIBPBD_TEMPLATE_MEMBER_API const std::string to_string() const
Definition: search_path.cc:99
ARDOUR::Plugin::_session
ARDOUR::Session & _session
Definition: plugin.h:286
LV2_Evbuf_Iterator
Definition: lv2_evbuf.h:51
ARDOUR::TempoMetric::tempo
const Tempo & tempo() const
Definition: tempo.h:197
Evoral::Parameter::type
uint32_t type() const
Definition: Parameter.hpp:47
PBD
Definition: debug.h:30
ARDOUR::Meter::divisions_per_bar
double divisions_per_bar() const
Definition: tempo.h:70
ARDOUR::LV2Plugin::has_editor
bool has_editor() const
Definition: lv2_plugin.cc:1161
Evoral::Beats::to_double
double to_double() const
Definition: Beats.hpp:185
ARDOUR::LV2Plugin::_latency_control_port
float * _latency_control_port
Special output set by ardour.
Definition: lv2_plugin.h:174
ARDOUR::Variant::get_int
int get_int() const
Definition: variant.h:121
ARDOUR::LV2Plugin::nth_parameter
uint32_t nth_parameter(uint32_t port, bool &ok) const
Definition: lv2_plugin.cc:818
ARDOUR::LV2Plugin::automatable
std::set< Evoral::Parameter > automatable() const
Definition: lv2_plugin.cc:1713
ARDOUR::ParameterDescriptor::scale_points
boost::shared_ptr< ScalePoints > scale_points
Definition: parameter_descriptor.h:54
ARDOUR::LV2Plugin::_port_indices
std::map< std::string, uint32_t > _port_indices
Definition: lv2_plugin.h:203
ARDOUR::TempoMap::metric_at
TempoMetric metric_at(Timecode::BBT_Time bbt) const
Definition: tempo.cc:1141
ARDOUR::Variant::DOUBLE
C double (64-bit IEEE-754)
Definition: variant.h:43
LV2World::lv2_minimum
LilvNode * lv2_minimum
Definition: lv2_plugin.cc:137
ARDOUR::Variant::get_string
const std::string & get_string() const
Definition: variant.h:137
ARDOUR::LV2Plugin::is_external_kx
bool is_external_kx() const
Definition: lv2_plugin.cc:654
log_vprintf
static int log_vprintf(LV2_Log_Handle, LV2_URID type, const char *fmt, va_list args)
Definition: lv2_plugin.cc:204
ARDOUR::MetricSection::frame
framepos_t frame() const
Definition: tempo.h:100
ARDOUR::URIMap::URIDs::patch_Set
uint32_t patch_Set
Definition: uri_map.h:83
failed_constructor
Definition: failed_constructor.h:27
work_schedule
static LV2_Worker_Status work_schedule(LV2_Worker_Schedule_Handle handle, uint32_t size, const void *data)
Definition: lv2_plugin.cc:169
ARDOUR::LV2Plugin::emit_to_ui
void emit_to_ui(void *controller, UIMessageSink sink)
Definition: lv2_plugin.cc:1500
LV2World::lv2_sampleRate
LilvNode * lv2_sampleRate
Definition: lv2_plugin.cc:140
ARDOUR::URIMap::URIDs::midi_MidiEvent
uint32_t midi_MidiEvent
Definition: uri_map.h:73
write_position
static bool write_position(LV2_Atom_Forge *forge, LV2_Evbuf *buf, const TempoMetric &t, Timecode::BBT_Time &bbt, double speed, framepos_t position, framecnt_t offset)
Definition: lv2_plugin.cc:1826
ARDOUR::PluginScanMessage
LIBARDOUR_API PBD::Signal3< void, std::string, std::string, bool > PluginScanMessage
Definition: globals.cc:136
LV2World::rdfs_comment
LilvNode * rdfs_comment
Definition: lv2_plugin.cc:143
ARDOUR::LV2Plugin::_instance_access_feature
LV2_Feature _instance_access_feature
Definition: lv2_plugin.h:235
ARDOUR::Variant::get_double
double get_double() const
Definition: variant.h:119
ARDOUR::Variant::NOTHING
Nothing (void)
Definition: variant.h:40
ARDOUR::MidiBuffer::begin
iterator begin()
Definition: midi_buffer.h:127
Evoral::Event::buffer
const uint8_t * buffer() const
Definition: Event.hpp:135
ARDOUR::LV2Plugin::get_parameter_docs
std::string get_parameter_docs(uint32_t which) const
Definition: lv2_plugin.cc:801
LV2World::lv2_AudioPort
LilvNode * lv2_AudioPort
Definition: lv2_plugin.cc:128
ARDOUR::URIMap::URIDs::patch_value
uint32_t patch_value
Definition: uri_map.h:85
ARDOUR::URIMap::URIDs::time_beatsPerMinute
uint32_t time_beatsPerMinute
Definition: uri_map.h:79
ARDOUR::LV2Plugin::_patch_port_in_index
uint32_t _patch_port_in_index
Definition: lv2_plugin.h:178
ARDOUR::PluginInfoList
std::list< PluginInfoPtr > PluginInfoList
Definition: plugin.h:90
ARDOUR::Plugin::set_cycles
void set_cycles(uint32_t c)
Definition: plugin.h:231
ARDOUR::AudioBuffer::data
const Sample * data(framecnt_t offset=0) const
Definition: audio_buffer.h:187
ARDOUR::LV2Plugin::get_parameter_descriptor
int get_parameter_descriptor(uint32_t which, ParameterDescriptor &) const
Definition: lv2_plugin.cc:1625
LV2World::patch_Message
LilvNode * patch_Message
Definition: lv2_plugin.cc:157
ARDOUR::PluginInfoPtr
boost::shared_ptr< PluginInfo > PluginInfoPtr
Definition: plugin.h:89
ARDOUR::URIMap::URIDs::patch_property
uint32_t patch_property
Definition: uri_map.h:84
ARDOUR::Session::externals_dir
std::string externals_dir() const
Links to external files.
Definition: session_state.cc:2260
ARDOUR::LV2Plugin::Impl::designated_input
const LilvPort * designated_input(const char *uri, void **bufptrs[], void **bufptr)
Definition: lv2_plugin.cc:2288
ARDOUR::LV2PluginInfo::load
PluginPtr load(Session &session)
Definition: lv2_plugin.cc:2434
get_value
static LilvNode * get_value(LilvWorld *world, const LilvNode *subject, const LilvNode *predicate)
Definition: lv2_plugin.cc:971
ARDOUR::LV2Plugin::_property_descriptors
PropertyDescriptors _property_descriptors
Definition: lv2_plugin.h:205
ARDOUR::LV2Plugin::write_to
bool write_to(RingBuffer< uint8_t > *dest, uint32_t index, uint32_t protocol, uint32_t size, const uint8_t *body)
Definition: lv2_plugin.cc:1179
LV2World::lv2_OutputPort
LilvNode * lv2_OutputPort
Definition: lv2_plugin.cc:131
LV2World::time_Position
LilvNode * time_Position
Definition: lv2_plugin.cc:147
audio_buffer.h
ARDOUR::LV2Plugin::Impl::instance
LilvInstance * instance
Definition: lv2_plugin.cc:250
LV2World::atom_AtomPort
LilvNode * atom_AtomPort
Definition: lv2_plugin.cc:119
LV2World::atom_supports
LilvNode * atom_supports
Definition: lv2_plugin.cc:124
ARDOUR::URIMap::URIDs::atom_Sequence
uint32_t atom_Sequence
Definition: uri_map.h:64
ARDOUR::ParameterDescriptor::datatype
Variant::Type datatype
for properties
Definition: parameter_descriptor.h:56
lv2_evbuf_reset
void lv2_evbuf_reset(LV2_Evbuf *evbuf, bool input)
Definition: lv2_evbuf.c:82
ARDOUR::LV2Plugin::_next_cycle_speed
double _next_cycle_speed
Expected start frame of next run cycle.
Definition: lv2_plugin.h:176
LV2World::lv2_default
LilvNode * lv2_default
Definition: lv2_plugin.cc:136
lv2_evbuf.h
XMLNodeConstIterator
XMLNodeList::const_iterator XMLNodeConstIterator
Definition: xml++.h:49
ARDOUR::Session::get_silent_buffers
BufferSet & get_silent_buffers(ChanCount count=ChanCount::ZERO)
Definition: session.cc:4845
ARDOUR::LV2Plugin::_has_state_interface
bool _has_state_interface
Definition: lv2_plugin.h:249
ARDOUR::URIMap::urid_unmap_feature
LV2_Feature * urid_unmap_feature()
Definition: uri_map.h:50
ARDOUR::LV2Plugin::lv2plugin_get_port_value
friend const void * lv2plugin_get_port_value(const char *port_symbol, void *user_data, uint32_t *size, uint32_t *type)
ARDOUR::LV2Plugin::_port_minimumSize
std::vector< size_t > _port_minimumSize
Definition: lv2_plugin.h:202
cycles_t
long cycles_t
Definition: cycles.h:226
ARDOUR::LV2Plugin::set_property
void set_property(uint32_t key, const Variant &value)
Definition: lv2_plugin.cc:1311
ARDOUR::LV2Plugin::_freewheel_control_port
float * _freewheel_control_port
Special input set by ardour.
Definition: lv2_plugin.h:173
ARDOUR::LV2Plugin::has_message_output
bool has_message_output() const
Definition: lv2_plugin.cc:1167
LV2World::lv2_reportsLatency
LilvNode * lv2_reportsLatency
Definition: lv2_plugin.cc:139
ARDOUR::Plugin::session
ARDOUR::Session & session() const
Definition: plugin.h:229
ARDOUR::Plugin::load_preset
virtual bool load_preset(PresetRecord)
Definition: plugin.cc:340
ARDOUR::Session::get_scratch_buffers
BufferSet & get_scratch_buffers(ChanCount count=ChanCount::ZERO, bool silence=true)
Definition: session.cc:4851
ARDOUR::ChanMapping::get
uint32_t get(DataType t, uint32_t from, bool *valid)
Definition: chan_mapping.cc:44
LV2World::ui_externalkx
LilvNode * ui_externalkx
Definition: lv2_plugin.cc:150
ARDOUR::URIMap::URIDs::atom_Blank
uint32_t atom_Blank
Definition: uri_map.h:67
ARDOUR::PluginInfo::type
ARDOUR::PluginType type
Definition: plugin.h:65
ARDOUR::PluginInfo::name
std::string name
Definition: plugin.h:59
ARDOUR::Session::engine
AudioEngine & engine()
Definition: session.h:546
ARDOUR::LV2Plugin::_atom_ev_buffers
LV2_Evbuf ** _atom_ev_buffers
Definition: lv2_plugin.h:171
ARDOUR::lv2_bundled_search_path
LIBARDOUR_API PBD::Searchpath lv2_bundled_search_path()
Definition: search_paths.cc:114
string_compose
std::string string_compose(const std::string &fmt, const T1 &o1)
Definition: compose.h:208
ARDOUR::LV2Plugin::do_save_preset
std::string do_save_preset(std::string)
Definition: lv2_plugin.cc:1075
ARDOUR::LV2Plugin::c_plugin
const void * c_plugin()
Definition: lv2_plugin.cc:840
PBD::atof
double atof(const string &s)
Definition: convert.cc:158
NBUFS
static const size_t NBUFS
Definition: lv2_plugin.cc:104
ARDOUR::URIMap::URIDs::atom_Float
uint32_t atom_Float
Definition: uri_map.h:69
ARDOUR::LV2Plugin::LV2_DataAccess::extension_data
const void *(* extension_data)(const char *uri)
Definition: lv2_plugin.h:230
ARDOUR::LV2Plugin::UIMessageSink
void UIMessageSink(void *controller, uint32_t index, uint32_t size, uint32_t format, const void *buffer)
Definition: lv2_plugin.h:138
ARDOUR::LV2Plugin::set_state
int set_state(const XMLNode &node, int version)
Definition: lv2_plugin.cc:1546
ARDOUR::LV2Plugin::port_symbol
const char * port_symbol(uint32_t port) const
Definition: lv2_plugin.cc:731
Generated on Sun May 24 2015 12:15:06 for ardour by   doxygen 1.8.8