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