libs/ardour/lv2_plugin.cc

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