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