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