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