libs/ardour/lv2_plugin.cc

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