libs/ardour/lv2_plugin.cc

   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
 100 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
 101     This needs to be roughly the number of cycles the UI will get around to
 102     actually processing the traffic.  Lower values are flakier but save memory.
 103 */
 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
 167 /** Called by the plugin to schedule non-RT work. */
 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
 184 /** Called by the plugin to respond to non-RT work. */
 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
 240         /** Find the LV2 input port with the given designation.
 241          * If found, bufptrs[port_index] will be set to bufptr.
 242          */
 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
 857 /** Directory for all plugin state. */
 858 const std::string
 859 LV2Plugin::plugin_dir() const
 860 {
 861         return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
 862 }
 863
 864 /** Directory for files created by the plugin (except during save). */
 865 const std::string
 866 LV2Plugin::scratch_dir() const
 867 {
 868         return Glib::build_filename(plugin_dir(), "scratch");
 869 }
 870
 871 /** Directory for snapshots of files in the scratch directory. */
 872 const std::string
 873 LV2Plugin::file_dir() const
 874 {
 875         return Glib::build_filename(plugin_dir(), "files");
 876 }
 877
 878 /** Directory to save state snapshot version @c num into. */
 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
 885 /** Implementation of state:makePath for files created at instantiation time.
 886  * Note this is not used for files created at save time (Lilv deals with that).
 887  */
 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         const string base_name = legalize_for_uri(name);
1078         const string file_name = base_name + ".ttl";
1079         const string bundle    = Glib::build_filename(
1080                 Glib::get_home_dir(),
1081                 Glib::build_filename(".lv2", base_name + ".lv2"));
1082
1083         LilvState* state = lilv_state_new_from_instance(
1084                 _impl->plugin,
1085                 _impl->instance,
1086                 _uri_map.urid_map(),
1087                 scratch_dir().c_str(),                   // file_dir
1088                 bundle.c_str(),                          // copy_dir
1089                 bundle.c_str(),                          // link_dir
1090                 bundle.c_str(),                          // save_dir
1091                 lv2plugin_get_port_value,                // get_value
1092                 (void*)this,                             // user_data
1093                 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE,  // flags
1094                 _features                                // features
1095         );
1096
1097         lilv_state_set_label(state, name.c_str());
1098         lilv_state_save(
1099                 _world.world,           // world
1100                 _uri_map.urid_map(),    // map
1101                 _uri_map.urid_unmap(),  // unmap
1102                 state,                  // state
1103                 NULL,                   // uri (NULL = use file URI)
1104                 bundle.c_str(),         // dir
1105                 file_name.c_str()       // filename
1106         );
1107
1108         lilv_state_free(state);
1109
1110         std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1111         LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1112         LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1113 #ifdef HAVE_LILV_0_19_2
1114         lilv_world_unload_resource(_world.world, node_preset);
1115         lilv_world_unload_bundle(_world.world, node_bundle);
1116 #endif
1117         lilv_world_load_bundle(_world.world, node_bundle);
1118         lilv_world_load_resource(_world.world, node_preset);
1119         lilv_node_free(node_bundle);
1120         lilv_node_free(node_preset);
1121         return uri;
1122 }
1123
1124 void
1125 LV2Plugin::do_remove_preset(string name)
1126 {
1127         string preset_file = Glib::build_filename(
1128                 Glib::get_home_dir(),
1129                 Glib::build_filename(
1130                         Glib::build_filename(".lv2", "presets"),
1131                         name + ".ttl"
1132                 )
1133         );
1134         ::g_unlink(preset_file.c_str());
1135 }
1136
1137 bool
1138 LV2Plugin::has_editor() const
1139 {
1140         return _impl->ui != NULL;
1141 }
1142
1143 bool
1144 LV2Plugin::has_message_output() const
1145 {
1146         for (uint32_t i = 0; i < num_ports(); ++i) {
1147                 if ((_port_flags[i] & PORT_SEQUENCE) &&
1148                     (_port_flags[i] & PORT_OUTPUT)) {
1149                         return true;
1150                 }
1151         }
1152         return false;
1153 }
1154
1155 bool
1156 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1157                     uint32_t             index,
1158                     uint32_t             protocol,
1159                     uint32_t             size,
1160                     const uint8_t*       body)
1161 {
1162         const uint32_t  buf_size = sizeof(UIMessage) + size;
1163         vector<uint8_t> buf(buf_size);
1164
1165         UIMessage* msg = (UIMessage*)&buf[0];
1166         msg->index    = index;
1167         msg->protocol = protocol;
1168         msg->size     = size;
1169         memcpy(msg + 1, body, size);
1170
1171         return (dest->write(&buf[0], buf_size) == buf_size);
1172 }
1173
1174 bool
1175 LV2Plugin::write_from_ui(uint32_t       index,
1176                          uint32_t       protocol,
1177                          uint32_t       size,
1178                          const uint8_t* body)
1179 {
1180         if (!_from_ui) {
1181                 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1182                 /* buffer data communication from plugin UI to plugin instance.
1183                  * this buffer needs to potentially hold
1184                  *   (port's minimumSize) * (audio-periods) / (UI-periods)
1185                  * bytes.
1186                  *
1187                  *  e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1188                  *  ui-periods = 25 Hz (SuperRapidScreenUpdate)
1189                  *  default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1190                  *
1191                  * it is NOT safe to overflow (msg.size will be misinterpreted)
1192                  */
1193                 uint32_t bufsiz = 32768;
1194                 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1195                         bufsiz =  lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1196                 }
1197                 rbs = max((size_t) bufsiz * 8, rbs);
1198                 _from_ui = new RingBuffer<uint8_t>(rbs);
1199         }
1200
1201         if (!write_to(_from_ui, index, protocol, size, body)) {
1202                 error << "Error writing from UI to plugin" << endmsg;
1203                 return false;
1204         }
1205         return true;
1206 }
1207
1208 bool
1209 LV2Plugin::write_to_ui(uint32_t       index,
1210                        uint32_t       protocol,
1211                        uint32_t       size,
1212                        const uint8_t* body)
1213 {
1214         if (!write_to(_to_ui, index, protocol, size, body)) {
1215                 error << "Error writing from plugin to UI" << endmsg;
1216                 return false;
1217         }
1218         return true;
1219 }
1220
1221 static void
1222 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1223 {
1224         switch (value.type()) {
1225         case Variant::NOTHING:
1226                 break;
1227         case Variant::BEATS:
1228                 // No atom type for this, just forge a double
1229                 lv2_atom_forge_double(forge, value.get_beats().to_double());
1230                 break;
1231         case Variant::BOOL:
1232                 lv2_atom_forge_bool(forge, value.get_bool());
1233                 break;
1234         case Variant::DOUBLE:
1235                 lv2_atom_forge_double(forge, value.get_double());
1236                 break;
1237         case Variant::FLOAT:
1238                 lv2_atom_forge_float(forge, value.get_float());
1239                 break;
1240         case Variant::INT:
1241                 lv2_atom_forge_int(forge, value.get_int());
1242                 break;
1243         case Variant::LONG:
1244                 lv2_atom_forge_long(forge, value.get_long());
1245                 break;
1246         case Variant::PATH:
1247                 lv2_atom_forge_path(
1248                         forge, value.get_path().c_str(), value.get_path().size());
1249                 break;
1250         case Variant::STRING:
1251                 lv2_atom_forge_string(
1252                         forge, value.get_string().c_str(), value.get_string().size());
1253                 break;
1254         case Variant::URI:
1255                 lv2_atom_forge_uri(
1256                         forge, value.get_uri().c_str(), value.get_uri().size());
1257                 break;
1258         }
1259 }
1260
1261 /** Get a variant type from a URI, return false iff no match found. */
1262 static bool
1263 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1264 {
1265         if (uri == LV2_ATOM__Bool) {
1266                 type = Variant::BOOL;
1267         } else if (uri == LV2_ATOM__Double) {
1268                 type = Variant::DOUBLE;
1269         } else if (uri == LV2_ATOM__Float) {
1270                 type = Variant::FLOAT;
1271         } else if (uri == LV2_ATOM__Int) {
1272                 type = Variant::INT;
1273         } else if (uri == LV2_ATOM__Long) {
1274                 type = Variant::LONG;
1275         } else if (uri == LV2_ATOM__Path) {
1276                 type = Variant::PATH;
1277         } else if (uri == LV2_ATOM__String) {
1278                 type = Variant::STRING;
1279         } else if (uri == LV2_ATOM__URI) {
1280                 type = Variant::URI;
1281         } else {
1282                 return false;
1283         }
1284         return true;
1285 }
1286
1287 void
1288 LV2Plugin::set_property(uint32_t key, const Variant& value)
1289 {
1290         if (_patch_port_in_index == (uint32_t)-1) {
1291                 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1292                 return;
1293         } else if (value.type() == Variant::NOTHING) {
1294                 error << "LV2: set_property called with void value" << endmsg;
1295                 return;
1296         }
1297
1298         // Set up forge to write to temporary buffer on the stack
1299         LV2_Atom_Forge*      forge = &_impl->ui_forge;
1300         LV2_Atom_Forge_Frame frame;
1301         uint8_t              buf[PATH_MAX];  // Ought to be enough for anyone...
1302
1303         lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1304
1305         // Serialize patch:Set message to set property
1306 #ifdef HAVE_LV2_1_10_0
1307         lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1308         lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1309         lv2_atom_forge_urid(forge, key);
1310         lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1311 #else
1312         lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1313         lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1314         lv2_atom_forge_urid(forge, key);
1315         lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1316 #endif
1317
1318         forge_variant(forge, value);
1319
1320         // Write message to UI=>Plugin ring
1321         const LV2_Atom* const atom = (const LV2_Atom*)buf;
1322         write_from_ui(_patch_port_in_index,
1323                       _uri_map.urids.atom_eventTransfer,
1324                       lv2_atom_total_size(atom),
1325                       (const uint8_t*)atom);
1326 }
1327
1328 const ParameterDescriptor&
1329 LV2Plugin::get_property_descriptor(uint32_t id) const
1330 {
1331         PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1332         if (p != _property_descriptors.end()) {
1333                 return p->second;
1334         }
1335         return Plugin::get_property_descriptor(id);
1336 }
1337
1338 static void
1339 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1340 {
1341         if (lilv_nodes_contains(units, _world.units_midiNote)) {
1342                 desc.unit = ParameterDescriptor::MIDI_NOTE;
1343         } else if (lilv_nodes_contains(units, _world.units_db)) {
1344                 desc.unit = ParameterDescriptor::DB;
1345         } else if (lilv_nodes_contains(units, _world.units_hz)) {
1346                 desc.unit = ParameterDescriptor::HZ;
1347         }
1348         if (lilv_nodes_size(units) > 0) {
1349                 const LilvNode* unit = lilv_nodes_get_first(units);
1350                 LilvNode* render = get_value(lworld, unit, _world.units_render);
1351                 if (render) {
1352                         desc.print_fmt = lilv_node_as_string(render);
1353                         lilv_node_free(render);
1354                 }
1355         }
1356 }
1357
1358 static void
1359 load_parameter_descriptor(LV2World&            world,
1360                           ParameterDescriptor& desc,
1361                           Variant::Type        datatype,
1362                           const LilvNode*      subject)
1363 {
1364         LilvWorld* lworld  = _world.world;
1365         LilvNode*  label   = get_value(lworld, subject, _world.rdfs_label);
1366         LilvNode*  def     = get_value(lworld, subject, _world.lv2_default);
1367         LilvNode*  minimum = get_value(lworld, subject, _world.lv2_minimum);
1368         LilvNode*  maximum = get_value(lworld, subject, _world.lv2_maximum);
1369         LilvNodes* units   = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1370         if (label) {
1371                 desc.label = lilv_node_as_string(label);
1372         }
1373         if (def && lilv_node_is_float(def)) {
1374                 desc.normal = lilv_node_as_float(def);
1375         }
1376         if (minimum && lilv_node_is_float(minimum)) {
1377                 desc.lower = lilv_node_as_float(minimum);
1378         }
1379         if (maximum && lilv_node_is_float(maximum)) {
1380                 desc.upper = lilv_node_as_float(maximum);
1381         }
1382         load_parameter_descriptor_units(lworld, desc, units);
1383         desc.datatype      = datatype;
1384         desc.toggled      |= datatype == Variant::BOOL;
1385         desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1386         desc.update_steps();
1387
1388         lilv_nodes_free(units);
1389         lilv_node_free(label);
1390         lilv_node_free(def);
1391         lilv_node_free(minimum);
1392         lilv_node_free(maximum);
1393 }
1394
1395 void
1396 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1397 {
1398         LilvWorld*       lworld     = _world.world;
1399         const LilvNode*  subject    = lilv_plugin_get_uri(_impl->plugin);
1400         LilvNodes*       properties = lilv_world_find_nodes(
1401                 lworld, subject, _world.patch_writable, NULL);
1402         LILV_FOREACH(nodes, p, properties) {
1403                 // Get label and range
1404                 const LilvNode* prop  = lilv_nodes_get(properties, p);
1405                 LilvNode*       range = get_value(lworld, prop, _world.rdfs_range);
1406                 if (!range) {
1407                         warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1408                                                   lilv_node_as_uri(prop)) << endmsg;
1409                         continue;
1410                 }
1411
1412                 // Convert range to variant type (TODO: support for multiple range types)
1413                 Variant::Type datatype;
1414                 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1415                         error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1416                                                 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1417                         continue;
1418                 }
1419
1420                 // Add description to result
1421                 ParameterDescriptor desc;
1422                 desc.key      = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1423                 desc.datatype = datatype;
1424                 load_parameter_descriptor(_world, desc, datatype, prop);
1425                 descs.insert(std::make_pair(desc.key, desc));
1426
1427                 lilv_node_free(range);
1428         }
1429         lilv_nodes_free(properties);
1430 }
1431
1432 void
1433 LV2Plugin::announce_property_values()
1434 {
1435         if (_patch_port_in_index == (uint32_t)-1) {
1436                 return;
1437         }
1438
1439         // Set up forge to write to temporary buffer on the stack
1440         LV2_Atom_Forge*      forge = &_impl->ui_forge;
1441         LV2_Atom_Forge_Frame frame;
1442         uint8_t              buf[PATH_MAX];  // Ought to be enough for anyone...
1443
1444         lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1445
1446         // Serialize patch:Get message with no subject (implicitly plugin instance)
1447 #ifdef HAVE_LV2_1_10_0
1448         lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1449 #else
1450         lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1451 #endif
1452
1453         // Write message to UI=>Plugin ring
1454         const LV2_Atom* const atom = (const LV2_Atom*)buf;
1455         write_from_ui(_patch_port_in_index,
1456                       _uri_map.urids.atom_eventTransfer,
1457                       lv2_atom_total_size(atom),
1458                       (const uint8_t*)atom);
1459 }
1460
1461 void
1462 LV2Plugin::enable_ui_emission()
1463 {
1464         if (!_to_ui) {
1465                 /* see note in LV2Plugin::write_from_ui() */
1466                 uint32_t bufsiz = 32768;
1467                 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1468                         bufsiz =  lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1469                 }
1470                 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1471                 rbs = max((size_t) bufsiz * 8, rbs);
1472                 _to_ui = new RingBuffer<uint8_t>(rbs);
1473         }
1474 }
1475
1476 void
1477 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1478 {
1479         if (!_to_ui) {
1480                 return;
1481         }
1482
1483         uint32_t read_space = _to_ui->read_space();
1484         while (read_space > sizeof(UIMessage)) {
1485                 UIMessage msg;
1486                 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1487                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1488                         break;
1489                 }
1490                 vector<uint8_t> body(msg.size);
1491                 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1492                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1493                         break;
1494                 }
1495
1496                 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1497
1498                 read_space -= sizeof(msg) + msg.size;
1499         }
1500 }
1501
1502 int
1503 LV2Plugin::work(uint32_t size, const void* data)
1504 {
1505         return _impl->work_iface->work(
1506                 _impl->instance->lv2_handle, work_respond, this, size, data);
1507 }
1508
1509 int
1510 LV2Plugin::work_response(uint32_t size, const void* data)
1511 {
1512         return _impl->work_iface->work_response(
1513                 _impl->instance->lv2_handle, size, data);
1514 }
1515
1516 void
1517 LV2Plugin::set_insert_id(PBD::ID id)
1518 {
1519         _insert_id = id;
1520 }
1521
1522 int
1523 LV2Plugin::set_state(const XMLNode& node, int version)
1524 {
1525         XMLNodeList          nodes;
1526         const XMLProperty*   prop;
1527         XMLNodeConstIterator iter;
1528         XMLNode*             child;
1529         const char*          sym;
1530         const char*          value;
1531         uint32_t             port_id;
1532         LocaleGuard          lg(X_("C"));
1533
1534         if (node.name() != state_node_name()) {
1535                 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1536                 return -1;
1537         }
1538
1539 #ifndef NO_PLUGIN_STATE
1540
1541         if (version < 3000) {
1542                 nodes = node.children("port");
1543         } else {
1544                 nodes = node.children("Port");
1545         }
1546
1547         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1548
1549                 child = *iter;
1550
1551                 if ((prop = child->property("symbol")) != 0) {
1552                         sym = prop->value().c_str();
1553                 } else {
1554                         warning << _("LV2: port has no symbol, ignored") << endmsg;
1555                         continue;
1556                 }
1557
1558                 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1559
1560                 if (i != _port_indices.end()) {
1561                         port_id = i->second;
1562                 } else {
1563                         warning << _("LV2: port has unknown index, ignored") << endmsg;
1564                         continue;
1565                 }
1566
1567                 if ((prop = child->property("value")) != 0) {
1568                         value = prop->value().c_str();
1569                 } else {
1570                         warning << _("LV2: port has no value, ignored") << endmsg;
1571                         continue;
1572                 }
1573
1574                 set_parameter(port_id, atof(value));
1575         }
1576
1577         _state_version = 0;
1578         if ((prop = node.property("state-dir")) != 0) {
1579                 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1580                         error << string_compose(
1581                                 "LV2: failed to parse state version from \"%1\"",
1582                                 prop->value()) << endmsg;
1583                 }
1584
1585                 std::string state_file = Glib::build_filename(
1586                         plugin_dir(),
1587                         Glib::build_filename(prop->value(), "state.ttl"));
1588
1589                 LilvState* state = lilv_state_new_from_file(
1590                         _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1591
1592                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1593         }
1594
1595         latency_compute_run();
1596 #endif
1597
1598         return Plugin::set_state(node, version);
1599 }
1600
1601 int
1602 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1603 {
1604         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1605         if (!port) {
1606                 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1607                       << endmsg;
1608                 return 1;
1609         }
1610
1611         LilvNodes* portunits;
1612         LilvNode *def, *min, *max;
1613         lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1614         portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1615
1616         // TODO: Once we can rely on lilv 0.18.0 being present,
1617         // load_parameter_descriptor() can be used for ports as well
1618         desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1619         desc.toggled      = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1620         desc.logarithmic  = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1621         desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1622         desc.label        = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1623         desc.normal       = def ? lilv_node_as_float(def) : 0.0f;
1624         desc.lower        = min ? lilv_node_as_float(min) : 0.0f;
1625         desc.upper        = max ? lilv_node_as_float(max) : 1.0f;
1626         load_parameter_descriptor_units(_world.world, desc, portunits);
1627
1628         if (desc.sr_dependent) {
1629                 desc.lower *= _session.frame_rate ();
1630                 desc.upper *= _session.frame_rate ();
1631         }
1632
1633         desc.min_unbound  = false; // TODO: LV2 extension required
1634         desc.max_unbound  = false; // TODO: LV2 extension required
1635
1636         desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1637         desc.scale_points = get_scale_points(which);
1638
1639         desc.update_steps();
1640
1641         lilv_node_free(def);
1642         lilv_node_free(min);
1643         lilv_node_free(max);
1644         lilv_nodes_free(portunits);
1645
1646         return 0;
1647 }
1648
1649 string
1650 LV2Plugin::describe_parameter(Evoral::Parameter which)
1651 {
1652         if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1653
1654                 if (lilv_port_has_property(_impl->plugin,
1655                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1656                         return X_("hidden");
1657                 }
1658
1659                 if (lilv_port_has_property(_impl->plugin,
1660                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1661                         return X_("hidden");
1662                 }
1663
1664                 if (lilv_port_has_property(_impl->plugin,
1665                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1666                         return X_("latency");
1667                 }
1668
1669                 LilvNode* name = lilv_port_get_name(_impl->plugin,
1670                                                     lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1671                 string ret(lilv_node_as_string(name));
1672                 lilv_node_free(name);
1673                 return ret;
1674         } else {
1675                 return "??";
1676         }
1677 }
1678
1679 framecnt_t
1680 LV2Plugin::signal_latency() const
1681 {
1682         if (_latency_control_port) {
1683                 return (framecnt_t)floor(*_latency_control_port);
1684         } else {
1685                 return 0;
1686         }
1687 }
1688
1689 set<Evoral::Parameter>
1690 LV2Plugin::automatable() const
1691 {
1692         set<Evoral::Parameter> ret;
1693
1694         for (uint32_t i = 0; i < parameter_count(); ++i) {
1695                 if (parameter_is_input(i) && parameter_is_control(i)) {
1696                         ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1697                 }
1698         }
1699
1700         for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1701              p != _property_descriptors.end();
1702              ++p) {
1703                 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1704         }
1705         return ret;
1706 }
1707
1708 void
1709 LV2Plugin::activate()
1710 {
1711         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1712
1713         if (!_was_activated) {
1714                 lilv_instance_activate(_impl->instance);
1715                 _was_activated = true;
1716         }
1717 }
1718
1719 void
1720 LV2Plugin::deactivate()
1721 {
1722         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1723
1724         if (_was_activated) {
1725                 lilv_instance_deactivate(_impl->instance);
1726                 _was_activated = false;
1727         }
1728 }
1729
1730 void
1731 LV2Plugin::cleanup()
1732 {
1733         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1734
1735         activate();
1736         deactivate();
1737         lilv_instance_free(_impl->instance);
1738         _impl->instance = NULL;
1739 }
1740
1741 void
1742 LV2Plugin::allocate_atom_event_buffers()
1743 {
1744         /* reserve local scratch buffers for ATOM event-queues */
1745         const LilvPlugin* p = _impl->plugin;
1746
1747         /* count non-MIDI atom event-ports
1748          * TODO: nicely ask drobilla to make a lilv_ call for that
1749          */
1750         int count_atom_out = 0;
1751         int count_atom_in = 0;
1752         int minimumSize = 32768; // TODO use a per-port minimum-size
1753         for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1754                 const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
1755                 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1756                         LilvNodes* buffer_types = lilv_port_get_value(
1757                                 p, port, _world.atom_bufferType);
1758                         LilvNodes* atom_supports = lilv_port_get_value(
1759                                 p, port, _world.atom_supports);
1760
1761                         if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1762                                         || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1763                                 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1764                                         count_atom_in++;
1765                                 }
1766                                 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1767                                         count_atom_out++;
1768                                 }
1769                                 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1770                                 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1771                                 if (min_size && lilv_node_is_int(min_size)) {
1772                                         minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1773                                 }
1774                                 lilv_nodes_free(min_size_v);
1775                         }
1776                         lilv_nodes_free(buffer_types);
1777                         lilv_nodes_free(atom_supports);
1778                 }
1779         }
1780
1781         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1782                                 name(), count_atom_in, count_atom_out));
1783
1784         const int total_atom_buffers = (count_atom_in + count_atom_out);
1785         if (_atom_ev_buffers || total_atom_buffers == 0) {
1786                 return;
1787         }
1788
1789         DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1790         _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1791         for (int i = 0; i < total_atom_buffers; ++i ) {
1792                 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1793                                 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1794         }
1795         _atom_ev_buffers[total_atom_buffers] = 0;
1796         return;
1797 }
1798
1799 /** Write an ardour position/time/tempo/meter as an LV2 event.
1800  * @return true on success.
1801  */
1802 static bool
1803 write_position(LV2_Atom_Forge*     forge,
1804                LV2_Evbuf*          buf,
1805                const TempoMetric&  t,
1806                Timecode::BBT_Time& bbt,
1807                double              speed,
1808                framepos_t          position,
1809                framecnt_t          offset)
1810 {
1811         const URIMap::URIDs& urids = URIMap::instance().urids;
1812
1813         uint8_t pos_buf[256];
1814         lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1815         LV2_Atom_Forge_Frame frame;
1816 #ifdef HAVE_LV2_1_10_0
1817         lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1818         lv2_atom_forge_key(forge, urids.time_frame);
1819         lv2_atom_forge_long(forge, position);
1820         lv2_atom_forge_key(forge, urids.time_speed);
1821         lv2_atom_forge_float(forge, speed);
1822         lv2_atom_forge_key(forge, urids.time_barBeat);
1823         lv2_atom_forge_float(forge, bbt.beats - 1 +
1824                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1825         lv2_atom_forge_key(forge, urids.time_bar);
1826         lv2_atom_forge_long(forge, bbt.bars - 1);
1827         lv2_atom_forge_key(forge, urids.time_beatUnit);
1828         lv2_atom_forge_int(forge, t.meter().note_divisor());
1829         lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1830         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1831         lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1832         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1833 #else
1834         lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1835         lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1836         lv2_atom_forge_long(forge, position);
1837         lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1838         lv2_atom_forge_float(forge, speed);
1839         lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1840         lv2_atom_forge_float(forge, bbt.beats - 1 +
1841                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1842         lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1843         lv2_atom_forge_long(forge, bbt.bars - 1);
1844         lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
1845         lv2_atom_forge_int(forge, t.meter().note_divisor());
1846         lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
1847         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1848         lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
1849         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1850 #endif
1851
1852         LV2_Evbuf_Iterator    end  = lv2_evbuf_end(buf);
1853         const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1854         return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1855                                (const uint8_t*)(atom + 1));
1856 }
1857
1858 int
1859 LV2Plugin::connect_and_run(BufferSet& bufs,
1860         ChanMapping in_map, ChanMapping out_map,
1861         pframes_t nframes, framecnt_t offset)
1862 {
1863         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1864         Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1865
1866         cycles_t then = get_cycles();
1867
1868         TempoMap&               tmap     = _session.tempo_map();
1869         Metrics::const_iterator metric_i = tmap.metrics_end();
1870         TempoMetric             tmetric  = tmap.metric_at(_session.transport_frame(), &metric_i);
1871
1872         if (_freewheel_control_port) {
1873                 *_freewheel_control_port = _session.engine().freewheeling();
1874         }
1875
1876         if (_bpm_control_port) {
1877                 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1878         }
1879
1880         ChanCount bufs_count;
1881         bufs_count.set(DataType::AUDIO, 1);
1882         bufs_count.set(DataType::MIDI, 1);
1883         BufferSet& silent_bufs  = _session.get_silent_buffers(bufs_count);
1884         BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1885         uint32_t const num_ports = parameter_count();
1886         uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1887
1888         uint32_t audio_in_index  = 0;
1889         uint32_t audio_out_index = 0;
1890         uint32_t midi_in_index   = 0;
1891         uint32_t midi_out_index  = 0;
1892         uint32_t atom_port_index = 0;
1893         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1894                 void*     buf   = NULL;
1895                 uint32_t  index = nil_index;
1896                 PortFlags flags = _port_flags[port_index];
1897                 bool      valid = false;
1898                 if (flags & PORT_AUDIO) {
1899                         if (flags & PORT_INPUT) {
1900                                 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1901                                 buf = (valid)
1902                                         ? bufs.get_audio(index).data(offset)
1903                                         : silent_bufs.get_audio(0).data(offset);
1904                         } else {
1905                                 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1906                                 buf = (valid)
1907                                         ? bufs.get_audio(index).data(offset)
1908                                         : scratch_bufs.get_audio(0).data(offset);
1909                         }
1910                 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1911                         /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1912                            be necessary, but the mapping is illegal in some cases.  Ideally
1913                            that should be fixed, but this is easier...
1914                         */
1915                         if (flags & PORT_MIDI) {
1916                                 if (flags & PORT_INPUT) {
1917                                         index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1918                                 } else {
1919                                         index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1920                                 }
1921                                 if (valid && bufs.count().n_midi() > index) {
1922                                         /* Note, ensure_lv2_bufsize() is not RT safe!
1923                                          * However free()/alloc() is only called if a
1924                                          * plugin requires a rsz:minimumSize buffersize
1925                                          * and the existing buffer if smaller.
1926                                          */
1927                                         bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1928                                         _ev_buffers[port_index] = bufs.get_lv2_midi(
1929                                                 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1930                                 }
1931                         } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1932                                 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1933                                 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1934                                 valid                   = true;
1935                         }
1936
1937                         if (valid && (flags & PORT_INPUT)) {
1938                                 Timecode::BBT_Time bbt;
1939                                 if ((flags & PORT_POSITION)) {
1940                                         if (_session.transport_frame() != _next_cycle_start ||
1941                                             _session.transport_speed() != _next_cycle_speed) {
1942                                                 // Transport has changed, write position at cycle start
1943                                                 tmap.bbt_time(_session.transport_frame(), bbt);
1944                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1945                                                                tmetric, bbt, _session.transport_speed(),
1946                                                                _session.transport_frame(), 0);
1947                                         }
1948                                 }
1949
1950                                 // Get MIDI iterator range (empty range if no MIDI)
1951                                 MidiBuffer::iterator m = (index != nil_index)
1952                                         ? bufs.get_midi(index).begin()
1953                                         : silent_bufs.get_midi(0).end();
1954                                 MidiBuffer::iterator m_end = (index != nil_index)
1955                                         ? bufs.get_midi(index).end()
1956                                         : m;
1957
1958                                 // Now merge MIDI and any transport events into the buffer
1959                                 const uint32_t     type = _uri_map.urids.midi_MidiEvent;
1960                                 const framepos_t   tend = _session.transport_frame() + nframes;
1961                                 ++metric_i;
1962                                 while (m != m_end || (metric_i != tmap.metrics_end() &&
1963                                                       (*metric_i)->frame() < tend)) {
1964                                         MetricSection* metric = (metric_i != tmap.metrics_end())
1965                                                 ? *metric_i : NULL;
1966                                         if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1967                                                 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1968                                                 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1969                                                 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1970                                                 ++m;
1971                                         } else {
1972                                                 tmetric.set_metric(metric);
1973                                                 bbt = metric->start();
1974                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1975                                                                tmetric, bbt, _session.transport_speed(),
1976                                                                metric->frame(),
1977                                                                metric->frame() - _session.transport_frame());
1978                                                 ++metric_i;
1979                                         }
1980                                 }
1981                         } else if (!valid) {
1982                                 // Nothing we understand or care about, connect to scratch
1983                                 // see note for midi-buffer size above
1984                                 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
1985                                                 0, _port_minimumSize[port_index]);
1986                                 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
1987                                         (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
1988                         }
1989
1990                         buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
1991                 } else {
1992                         continue;  // Control port, leave buffer alone
1993                 }
1994                 lilv_instance_connect_port(_impl->instance, port_index, buf);
1995         }
1996
1997         // Read messages from UI and push into appropriate buffers
1998         if (_from_ui) {
1999                 uint32_t read_space = _from_ui->read_space();
2000                 while (read_space > sizeof(UIMessage)) {
2001                         UIMessage msg;
2002                         if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2003                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2004                                 break;
2005                         }
2006                         vector<uint8_t> body(msg.size);
2007                         if (_from_ui->read(&body[0], msg.size) != msg.size) {
2008                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2009                                 break;
2010                         }
2011                         if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2012                                 LV2_Evbuf*            buf  = _ev_buffers[msg.index];
2013                                 LV2_Evbuf_Iterator    i    = lv2_evbuf_end(buf);
2014                                 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2015                                 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2016                                                 (const uint8_t*)(atom + 1))) {
2017                                         error << "Failed to write data to LV2 event buffer\n";
2018                                 }
2019                         } else {
2020                                 error << "Received unknown message type from UI" << endmsg;
2021                         }
2022                         read_space -= sizeof(UIMessage) + msg.size;
2023                 }
2024         }
2025
2026         run(nframes);
2027
2028         midi_out_index = 0;
2029         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2030                 PortFlags flags = _port_flags[port_index];
2031                 bool      valid = false;
2032
2033                 /* TODO ask drobilla about comment
2034                  * "Make Ardour event buffers generic so plugins can communicate"
2035                  * in libs/ardour/buffer_set.cc:310
2036                  *
2037                  * ideally the user could choose which of the following two modes
2038                  * to use (e.g. instrument/effect chains  MIDI OUT vs MIDI TRHU).
2039                  *
2040                  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2041                  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2042                  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2043                  *                            for quite a while at least ;)
2044                  */
2045                 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2046                 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2047                         const uint32_t buf_index = out_map.get(
2048                                 DataType::MIDI, midi_out_index++, &valid);
2049                         if (valid) {
2050                                 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2051                         }
2052                 }
2053                 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2054                 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2055                         const uint32_t buf_index = out_map.get(
2056                                 DataType::MIDI, midi_out_index++, &valid);
2057                         if (valid) {
2058                                 bufs.flush_lv2_midi(true, buf_index);
2059                         }
2060                 }
2061
2062
2063                 // Write messages to UI
2064                 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2065                     (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2066                         LV2_Evbuf* buf = _ev_buffers[port_index];
2067                         for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2068                              lv2_evbuf_is_valid(i);
2069                              i = lv2_evbuf_next(i)) {
2070                                 uint32_t frames, subframes, type, size;
2071                                 uint8_t* data;
2072                                 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2073
2074                                 // Intercept patch change messages to emit PropertyChanged signal
2075                                 if ((flags & PORT_PATCHMSG)) {
2076                                         LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2077                                         if (atom->type == _uri_map.urids.atom_Blank ||
2078                                             atom->type == _uri_map.urids.atom_Object) {
2079                                                 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2080                                                 if (obj->body.otype == _uri_map.urids.patch_Set) {
2081                                                         const LV2_Atom* property = NULL;
2082                                                         const LV2_Atom* value    = NULL;
2083                                                         lv2_atom_object_get(obj,
2084                                                                             _uri_map.urids.patch_property, &property,
2085                                                                             _uri_map.urids.patch_value,    &value,
2086                                                                             0);
2087
2088                                                         if (!property || !value ||
2089                                                             property->type != _uri_map.urids.atom_URID ||
2090                                                             value->type    != _uri_map.urids.atom_Path) {
2091                                                                 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2092                                                                 continue;
2093                                                         }
2094
2095                                                         const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2096                                                         const char*    path    = (const char*)LV2_ATOM_BODY_CONST(value);
2097
2098                                                         // Emit PropertyChanged signal for UI
2099                                                         // TODO: This should emit the control's Changed signal
2100                                                         PropertyChanged(prop_id, Variant(Variant::PATH, path));
2101                                                 }
2102                                         }
2103                                 }
2104
2105                                 if (!_to_ui) continue;
2106                                 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2107                                             size + sizeof(LV2_Atom),
2108                                             data - sizeof(LV2_Atom));
2109                         }
2110                 }
2111         }
2112
2113         cycles_t now = get_cycles();
2114         set_cycles((uint32_t)(now - then));
2115
2116         // Update expected transport information for next cycle so we can detect changes
2117         _next_cycle_speed = _session.transport_speed();
2118         _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2119
2120         return 0;
2121 }
2122
2123 bool
2124 LV2Plugin::parameter_is_control(uint32_t param) const
2125 {
2126         assert(param < _port_flags.size());
2127         return _port_flags[param] & PORT_CONTROL;
2128 }
2129
2130 bool
2131 LV2Plugin::parameter_is_audio(uint32_t param) const
2132 {
2133         assert(param < _port_flags.size());
2134         return _port_flags[param] & PORT_AUDIO;
2135 }
2136
2137 bool
2138 LV2Plugin::parameter_is_event(uint32_t param) const
2139 {
2140         assert(param < _port_flags.size());
2141         return _port_flags[param] & PORT_EVENT;
2142 }
2143
2144 bool
2145 LV2Plugin::parameter_is_output(uint32_t param) const
2146 {
2147         assert(param < _port_flags.size());
2148         return _port_flags[param] & PORT_OUTPUT;
2149 }
2150
2151 bool
2152 LV2Plugin::parameter_is_input(uint32_t param) const
2153 {
2154         assert(param < _port_flags.size());
2155         return _port_flags[param] & PORT_INPUT;
2156 }
2157
2158 void
2159 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2160 {
2161         if (buf && len) {
2162                 if (param < parameter_count()) {
2163                         snprintf(buf, len, "%.3f", get_parameter(param));
2164                 } else {
2165                         strcat(buf, "0");
2166                 }
2167         }
2168 }
2169
2170 boost::shared_ptr<ScalePoints>
2171 LV2Plugin::get_scale_points(uint32_t port_index) const
2172 {
2173         const LilvPort*  port   = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2174         LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2175
2176         boost::shared_ptr<ScalePoints> ret;
2177         if (!points) {
2178                 return ret;
2179         }
2180
2181         ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2182
2183         LILV_FOREACH(scale_points, i, points) {
2184                 const LilvScalePoint* p     = lilv_scale_points_get(points, i);
2185                 const LilvNode*       label = lilv_scale_point_get_label(p);
2186                 const LilvNode*       value = lilv_scale_point_get_value(p);
2187                 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2188                         ret->insert(make_pair(lilv_node_as_string(label),
2189                                               lilv_node_as_float(value)));
2190                 }
2191         }
2192
2193         lilv_scale_points_free(points);
2194         return ret;
2195 }
2196
2197 void
2198 LV2Plugin::run(pframes_t nframes)
2199 {
2200         uint32_t const N = parameter_count();
2201         for (uint32_t i = 0; i < N; ++i) {
2202                 if (parameter_is_control(i) && parameter_is_input(i)) {
2203                         _control_data[i] = _shadow_data[i];
2204                 }
2205         }
2206
2207         lilv_instance_run(_impl->instance, nframes);
2208
2209         if (_impl->work_iface) {
2210                 _worker->emit_responses();
2211                 if (_impl->work_iface->end_run) {
2212                         _impl->work_iface->end_run(_impl->instance->lv2_handle);
2213                 }
2214         }
2215 }
2216
2217 void
2218 LV2Plugin::latency_compute_run()
2219 {
2220         if (!_latency_control_port) {
2221                 return;
2222         }
2223
2224         // Run the plugin so that it can set its latency parameter
2225
2226         bool was_activated = _was_activated;
2227         activate();
2228
2229         uint32_t port_index = 0;
2230         uint32_t in_index   = 0;
2231         uint32_t out_index  = 0;
2232
2233         // this is done in the main thread. non realtime.
2234         const framecnt_t bufsize = _engine.samples_per_cycle();
2235         float            *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2236
2237         memset(buffer, 0, sizeof(float) * bufsize);
2238
2239         // FIXME: Ensure plugins can handle in-place processing
2240
2241         port_index = 0;
2242
2243         while (port_index < parameter_count()) {
2244                 if (parameter_is_audio(port_index)) {
2245                         if (parameter_is_input(port_index)) {
2246                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2247                                 in_index++;
2248                         } else if (parameter_is_output(port_index)) {
2249                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2250                                 out_index++;
2251                         }
2252                 }
2253                 port_index++;
2254         }
2255
2256         run(bufsize);
2257         deactivate();
2258         if (was_activated) {
2259                 activate();
2260         }
2261         free(buffer);
2262 }
2263
2264 const LilvPort*
2265 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2266 {
2267         const LilvPort* port = NULL;
2268         LilvNode* designation = lilv_new_uri(_world.world, uri);
2269         port = lilv_plugin_get_port_by_designation(
2270                 plugin, _world.lv2_InputPort, designation);
2271         lilv_node_free(designation);
2272         if (port) {
2273                 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2274         }
2275         return port;
2276 }
2277
2278 static bool lv2_filter (const string& str, void* /*arg*/)
2279 {
2280         /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2281
2282         return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2283 }
2284
2285
2286 LV2World::LV2World()
2287         : world(lilv_world_new())
2288         , _bundle_checked(false)
2289 {
2290         atom_AtomPort      = lilv_new_uri(world, LV2_ATOM__AtomPort);
2291         atom_Chunk         = lilv_new_uri(world, LV2_ATOM__Chunk);
2292         atom_Sequence      = lilv_new_uri(world, LV2_ATOM__Sequence);
2293         atom_bufferType    = lilv_new_uri(world, LV2_ATOM__bufferType);
2294         atom_supports      = lilv_new_uri(world, LV2_ATOM__supports);
2295         atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2296         ev_EventPort       = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2297         ext_logarithmic    = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2298         ext_notOnGUI       = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2299         lv2_AudioPort      = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2300         lv2_ControlPort    = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2301         lv2_InputPort      = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2302         lv2_OutputPort     = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2303         lv2_inPlaceBroken  = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2304         lv2_integer        = lilv_new_uri(world, LV2_CORE__integer);
2305         lv2_default        = lilv_new_uri(world, LV2_CORE__default);
2306         lv2_minimum        = lilv_new_uri(world, LV2_CORE__minimum);
2307         lv2_maximum        = lilv_new_uri(world, LV2_CORE__maximum);
2308         lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2309         lv2_sampleRate     = lilv_new_uri(world, LV2_CORE__sampleRate);
2310         lv2_toggled        = lilv_new_uri(world, LV2_CORE__toggled);
2311         lv2_enumeration    = lilv_new_uri(world, LV2_CORE__enumeration);
2312         lv2_freewheeling   = lilv_new_uri(world, LV2_CORE__freeWheeling);
2313         midi_MidiEvent     = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2314         rdfs_comment       = lilv_new_uri(world, LILV_NS_RDFS "comment");
2315         rdfs_label         = lilv_new_uri(world, LILV_NS_RDFS "label");
2316         rdfs_range         = lilv_new_uri(world, LILV_NS_RDFS "range");
2317         rsz_minimumSize    = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2318         time_Position      = lilv_new_uri(world, LV2_TIME__Position);
2319         ui_GtkUI           = lilv_new_uri(world, LV2_UI__GtkUI);
2320         ui_external        = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2321         ui_externalkx      = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2322         units_unit         = lilv_new_uri(world, LV2_UNITS__unit);
2323         units_render       = lilv_new_uri(world, LV2_UNITS__render);
2324         units_hz           = lilv_new_uri(world, LV2_UNITS__hz);
2325         units_midiNote     = lilv_new_uri(world, LV2_UNITS__midiNote);
2326         units_db           = lilv_new_uri(world, LV2_UNITS__db);
2327         patch_writable     = lilv_new_uri(world, LV2_PATCH__writable);
2328         patch_Message      = lilv_new_uri(world, LV2_PATCH__Message);
2329 }
2330
2331 LV2World::~LV2World()
2332 {
2333         lilv_node_free(patch_Message);
2334         lilv_node_free(patch_writable);
2335         lilv_node_free(units_hz);
2336         lilv_node_free(units_midiNote);
2337         lilv_node_free(units_db);
2338         lilv_node_free(units_unit);
2339         lilv_node_free(units_render);
2340         lilv_node_free(ui_externalkx);
2341         lilv_node_free(ui_external);
2342         lilv_node_free(ui_GtkUI);
2343         lilv_node_free(time_Position);
2344         lilv_node_free(rsz_minimumSize);
2345         lilv_node_free(rdfs_comment);
2346         lilv_node_free(rdfs_label);
2347         lilv_node_free(rdfs_range);
2348         lilv_node_free(midi_MidiEvent);
2349         lilv_node_free(lv2_enumeration);
2350         lilv_node_free(lv2_freewheeling);
2351         lilv_node_free(lv2_toggled);
2352         lilv_node_free(lv2_sampleRate);
2353         lilv_node_free(lv2_reportsLatency);
2354         lilv_node_free(lv2_integer);
2355         lilv_node_free(lv2_inPlaceBroken);
2356         lilv_node_free(lv2_OutputPort);
2357         lilv_node_free(lv2_InputPort);
2358         lilv_node_free(lv2_ControlPort);
2359         lilv_node_free(lv2_AudioPort);
2360         lilv_node_free(ext_notOnGUI);
2361         lilv_node_free(ext_logarithmic);
2362         lilv_node_free(ev_EventPort);
2363         lilv_node_free(atom_supports);
2364         lilv_node_free(atom_eventTransfer);
2365         lilv_node_free(atom_bufferType);
2366         lilv_node_free(atom_Sequence);
2367         lilv_node_free(atom_Chunk);
2368         lilv_node_free(atom_AtomPort);
2369         lilv_world_free(world);
2370 }
2371
2372 void
2373 LV2World::load_bundled_plugins(bool verbose)
2374 {
2375         if (!_bundle_checked) {
2376                 if (verbose) {
2377                         cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2378                 }
2379
2380                 vector<string> plugin_objects;
2381                 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2382                 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2383 #ifdef PLATFORM_WINDOWS
2384                         string uri = "file:///" + *x + "/";
2385 #else
2386                         string uri = "file://" + *x + "/";
2387 #endif
2388                         LilvNode *node = lilv_new_uri(world, uri.c_str());
2389                         lilv_world_load_bundle(world, node);
2390                         lilv_node_free(node);
2391                 }
2392
2393                 lilv_world_load_all(world);
2394                 _bundle_checked = true;
2395         }
2396 }
2397
2398 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2399 {
2400         type = ARDOUR::LV2;
2401         _plugin_uri = strdup(plugin_uri);
2402 }
2403
2404 LV2PluginInfo::~LV2PluginInfo()
2405 {
2406         free(_plugin_uri);
2407         _plugin_uri = NULL;
2408 }
2409
2410 PluginPtr
2411 LV2PluginInfo::load(Session& session)
2412 {
2413         try {
2414                 PluginPtr plugin;
2415                 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2416                 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2417                 if (!uri) { throw failed_constructor(); }
2418                 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2419                 if (!lp) { throw failed_constructor(); }
2420                 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2421                 lilv_node_free(uri);
2422                 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2423                 return plugin;
2424         } catch (failed_constructor& err) {
2425                 return PluginPtr((Plugin*)0);
2426         }
2427
2428         return PluginPtr();
2429 }
2430
2431 PluginInfoList*
2432 LV2PluginInfo::discover()
2433 {
2434         LV2World world;
2435         world.load_bundled_plugins();
2436         _world.load_bundled_plugins(true);
2437
2438         PluginInfoList*    plugs   = new PluginInfoList;
2439         const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2440
2441         LILV_FOREACH(plugins, i, plugins) {
2442                 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2443                 const LilvNode* pun = lilv_plugin_get_uri(p);
2444                 if (!pun) continue;
2445                 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2446
2447                 LilvNode* name = lilv_plugin_get_name(p);
2448                 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2449                         warning << "Ignoring invalid LV2 plugin "
2450                                 << lilv_node_as_string(lilv_plugin_get_uri(p))
2451                                 << endmsg;
2452                         continue;
2453                 }
2454
2455                 info->type = LV2;
2456
2457                 info->name = string(lilv_node_as_string(name));
2458                 lilv_node_free(name);
2459                 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2460
2461                 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2462                 const LilvNode*        label  = lilv_plugin_class_get_label(pclass);
2463                 info->category = lilv_node_as_string(label);
2464
2465                 LilvNode* author_name = lilv_plugin_get_author_name(p);
2466                 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2467                 lilv_node_free(author_name);
2468
2469                 info->path = "/NOPATH"; // Meaningless for LV2
2470
2471                 /* count atom-event-ports that feature
2472                  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2473                  *
2474                  * TODO: nicely ask drobilla to make a lilv_ call for that
2475                  */
2476                 int count_midi_out = 0;
2477                 int count_midi_in = 0;
2478                 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2479                         const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
2480                         if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2481                                 LilvNodes* buffer_types = lilv_port_get_value(
2482                                         p, port, world.atom_bufferType);
2483                                 LilvNodes* atom_supports = lilv_port_get_value(
2484                                         p, port, world.atom_supports);
2485
2486                                 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2487                                                 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2488                                         if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2489                                                 count_midi_in++;
2490                                         }
2491                                         if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2492                                                 count_midi_out++;
2493                                         }
2494                                 }
2495                                 lilv_nodes_free(buffer_types);
2496                                 lilv_nodes_free(atom_supports);
2497                         }
2498                 }
2499
2500                 info->n_inputs.set_audio(
2501                         lilv_plugin_get_num_ports_of_class(
2502                                 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2503                 info->n_inputs.set_midi(
2504                         lilv_plugin_get_num_ports_of_class(
2505                                 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2506                         + count_midi_in);
2507
2508                 info->n_outputs.set_audio(
2509                         lilv_plugin_get_num_ports_of_class(
2510                                 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2511                 info->n_outputs.set_midi(
2512                         lilv_plugin_get_num_ports_of_class(
2513                                 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2514                         + count_midi_out);
2515
2516                 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2517                 info->index     = 0; // Meaningless for LV2
2518
2519                 plugs->push_back(info);
2520         }
2521
2522         return plugs;
2523 }