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         return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
 972 }
 973
 974 /** Directory for files created by the plugin (except during save). */
 975 const std::string
 976 LV2Plugin::scratch_dir() const
 977 {
 978         return Glib::build_filename(plugin_dir(), "scratch");
 979 }
 980
 981 /** Directory for snapshots of files in the scratch directory. */
 982 const std::string
 983 LV2Plugin::file_dir() const
 984 {
 985         return Glib::build_filename(plugin_dir(), "files");
 986 }
 987
 988 /** Directory to save state snapshot version @c num into. */
 989 const std::string
 990 LV2Plugin::state_dir(unsigned num) const
 991 {
 992         return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
 993 }
 994
 995 /** Implementation of state:makePath for files created at instantiation time.
 996  * Note this is not used for files created at save time (Lilv deals with that).
 997  */
 998 char*
 999 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1000                                const char*                path)
1001 {
1002         LV2Plugin* me = (LV2Plugin*)handle;
1003         if (me->_insert_id == PBD::ID("0")) {
1004                 warning << string_compose(
1005                         "File path \"%1\" requested but LV2 %2 has no insert ID",
1006                         path, me->name()) << endmsg;
1007                 return g_strdup(path);
1008         }
1009
1010         const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1011         const std::string dirname  = Glib::path_get_dirname(abs_path);
1012         g_mkdir_with_parents(dirname.c_str(), 0744);
1013
1014         DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1015                                                path, abs_path));
1016
1017         return g_strndup(abs_path.c_str(), abs_path.length());
1018 }
1019
1020 void
1021 LV2Plugin::add_state(XMLNode* root) const
1022 {
1023         assert(_insert_id != PBD::ID("0"));
1024
1025         XMLNode*    child;
1026         char        buf[32];
1027         LocaleGuard lg(X_("C"));
1028
1029         for (uint32_t i = 0; i < parameter_count(); ++i) {
1030                 if (parameter_is_input(i) && parameter_is_control(i)) {
1031                         child = new XMLNode("Port");
1032                         child->add_property("symbol", port_symbol(i));
1033                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1034                         child->add_property("value", string(buf));
1035                         root->add_child_nocopy(*child);
1036                 }
1037         }
1038
1039         if (_has_state_interface) {
1040                 // Provisionally increment state version and create directory
1041                 const std::string new_dir = state_dir(++_state_version);
1042                 g_mkdir_with_parents(new_dir.c_str(), 0744);
1043
1044                 LilvState* state = lilv_state_new_from_instance(
1045                         _impl->plugin,
1046                         _impl->instance,
1047                         _uri_map.urid_map(),
1048                         scratch_dir().c_str(),
1049                         file_dir().c_str(),
1050                         _session.externals_dir().c_str(),
1051                         new_dir.c_str(),
1052                         NULL,
1053                         const_cast<LV2Plugin*>(this),
1054                         0,
1055                         NULL);
1056
1057                 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
1058                         lilv_state_save(_world.world,
1059                                         _uri_map.urid_map(),
1060                                         _uri_map.urid_unmap(),
1061                                         state,
1062                                         NULL,
1063                                         new_dir.c_str(),
1064                                         "state.ttl");
1065
1066                         lilv_state_free(_impl->state);
1067                         _impl->state = state;
1068                 } else {
1069                         // State is identical, decrement version and nuke directory
1070                         lilv_state_free(state);
1071                         PBD::remove_directory(new_dir);
1072                         --_state_version;
1073                 }
1074
1075                 root->add_property("state-dir", string_compose("state%1", _state_version));
1076         }
1077 }
1078
1079 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1080 static LilvNode*
1081 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1082 {
1083         LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1084         if (vs) {
1085                 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1086                 lilv_nodes_free(vs);
1087                 return node;
1088         }
1089         return NULL;
1090 }
1091
1092 void
1093 LV2Plugin::find_presets()
1094 {
1095         LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1096         LilvNode* pset_Preset   = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1097         LilvNode* rdfs_label    = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1098
1099         LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1100         LILV_FOREACH(nodes, i, presets) {
1101                 const LilvNode* preset = lilv_nodes_get(presets, i);
1102                 lilv_world_load_resource(_world.world, preset);
1103                 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1104                 if (name) {
1105                         _presets.insert(std::make_pair(lilv_node_as_string(preset),
1106                                                        Plugin::PresetRecord(
1107                                                                lilv_node_as_string(preset),
1108                                                                lilv_node_as_string(name))));
1109                         lilv_node_free(name);
1110                 } else {
1111                         warning << string_compose(
1112                             _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1113                             lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1114                             lilv_node_as_string(preset)) << endmsg;
1115                 }
1116         }
1117         lilv_nodes_free(presets);
1118
1119         lilv_node_free(rdfs_label);
1120         lilv_node_free(pset_Preset);
1121         lilv_node_free(lv2_appliesTo);
1122 }
1123
1124 static void
1125 set_port_value(const char* port_symbol,
1126                void*       user_data,
1127                const void* value,
1128                uint32_t    /*size*/,
1129                uint32_t    type)
1130 {
1131         LV2Plugin* self = (LV2Plugin*)user_data;
1132         if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1133                 return;  // TODO: Support non-float ports
1134         }
1135
1136         const uint32_t port_index = self->port_index(port_symbol);
1137         if (port_index != (uint32_t)-1) {
1138                 self->set_parameter(port_index, *(const float*)value);
1139         }
1140 }
1141
1142 bool
1143 LV2Plugin::load_preset(PresetRecord r)
1144 {
1145         LilvWorld* world = _world.world;
1146         LilvNode*  pset  = lilv_new_uri(world, r.uri.c_str());
1147         LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1148
1149         if (state) {
1150                 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1151                 lilv_state_free(state);
1152                 Plugin::load_preset(r);
1153         }
1154
1155         lilv_node_free(pset);
1156         return state;
1157 }
1158
1159 const void*
1160 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1161                                  void*       user_data,
1162                                  uint32_t*   size,
1163                                  uint32_t*   type)
1164 {
1165         LV2Plugin *plugin = (LV2Plugin *) user_data;
1166
1167         uint32_t index = plugin->port_index(port_symbol);
1168         if (index != (uint32_t) -1) {
1169                 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1170                         float *value;
1171                         *size = sizeof(float);
1172                         *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1173                         value = &plugin->_shadow_data[index];
1174
1175                         return value;
1176                 }
1177         }
1178
1179         *size = *type = 0;
1180         return NULL;
1181 }
1182
1183
1184 std::string
1185 LV2Plugin::do_save_preset(string name)
1186 {
1187         LilvNode*    plug_name = lilv_plugin_get_name(_impl->plugin);
1188         const string prefix    = legalize_for_uri(lilv_node_as_string(plug_name));
1189         const string base_name = legalize_for_uri(name);
1190         const string file_name = base_name + ".ttl";
1191         const string bundle    = Glib::build_filename(
1192                 Glib::get_home_dir(),
1193                 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1194
1195 #ifdef HAVE_LILV_0_21_3
1196         /* delete reference to old preset (if any) */
1197         const PresetRecord* r = preset_by_label(name);
1198         if (r) {
1199                 LilvNode*  pset  = lilv_new_uri (_world.world, r->uri.c_str());
1200                 if (pset) {
1201                         lilv_world_unload_resource (_world.world, pset);
1202                         lilv_node_free(pset);
1203                 }
1204         }
1205 #endif
1206
1207         LilvState* state = lilv_state_new_from_instance(
1208                 _impl->plugin,
1209                 _impl->instance,
1210                 _uri_map.urid_map(),
1211                 scratch_dir().c_str(),                   // file_dir
1212                 bundle.c_str(),                          // copy_dir
1213                 bundle.c_str(),                          // link_dir
1214                 bundle.c_str(),                          // save_dir
1215                 lv2plugin_get_port_value,                // get_value
1216                 (void*)this,                             // user_data
1217                 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE,  // flags
1218                 _features                                // features
1219         );
1220
1221         lilv_state_set_label(state, name.c_str());
1222         lilv_state_save(
1223                 _world.world,           // world
1224                 _uri_map.urid_map(),    // map
1225                 _uri_map.urid_unmap(),  // unmap
1226                 state,                  // state
1227                 NULL,                   // uri (NULL = use file URI)
1228                 bundle.c_str(),         // dir
1229                 file_name.c_str()       // filename
1230         );
1231
1232         lilv_state_free(state);
1233
1234         std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1235         LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1236         LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1237 #ifdef HAVE_LILV_0_21_3
1238         lilv_world_unload_resource(_world.world, node_preset);
1239         lilv_world_unload_bundle(_world.world, node_bundle);
1240 #endif
1241         lilv_world_load_bundle(_world.world, node_bundle);
1242         lilv_world_load_resource(_world.world, node_preset);
1243         lilv_node_free(node_bundle);
1244         lilv_node_free(node_preset);
1245         lilv_node_free(plug_name);
1246         return uri;
1247 }
1248
1249 void
1250 LV2Plugin::do_remove_preset(string name)
1251 {
1252 #ifdef HAVE_LILV_0_21_3
1253         /* Look up preset record by label (FIXME: ick, label as ID) */
1254         const PresetRecord* r = preset_by_label(name);
1255         if (!r) {
1256                 return;
1257         }
1258
1259         /* Load a LilvState for the preset. */
1260         LilvWorld* world = _world.world;
1261         LilvNode*  pset  = lilv_new_uri(world, r->uri.c_str());
1262         LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1263         if (!state) {
1264                 lilv_node_free(pset);
1265                 return;
1266         }
1267
1268         /* Unload preset from world. */
1269         lilv_world_unload_resource(world, pset);
1270
1271         /* Delete it from the file system.  This will remove the preset file and the entry
1272            from the manifest.  If this results in an empty manifest (i.e. the
1273            preset is the only thing in the bundle), then the bundle is removed. */
1274         lilv_state_delete(world, state);
1275
1276         lilv_state_free(state);
1277         lilv_node_free(pset);
1278 #endif
1279         /* Without lilv_state_delete(), we could delete the preset file, but this
1280            would leave a broken bundle/manifest around, so the preset would still
1281            be visible, but broken.  Naively deleting a bundle is too dangerous, so
1282            we simply do not support preset deletion with older Lilv */
1283 }
1284
1285 bool
1286 LV2Plugin::has_editor() const
1287 {
1288         return _impl->ui != NULL;
1289 }
1290
1291 bool
1292 LV2Plugin::has_message_output() const
1293 {
1294         for (uint32_t i = 0; i < num_ports(); ++i) {
1295                 if ((_port_flags[i] & PORT_SEQUENCE) &&
1296                     (_port_flags[i] & PORT_OUTPUT)) {
1297                         return true;
1298                 }
1299         }
1300         return false;
1301 }
1302
1303 bool
1304 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1305                     uint32_t             index,
1306                     uint32_t             protocol,
1307                     uint32_t             size,
1308                     const uint8_t*       body)
1309 {
1310         const uint32_t  buf_size = sizeof(UIMessage) + size;
1311         vector<uint8_t> buf(buf_size);
1312
1313         UIMessage* msg = (UIMessage*)&buf[0];
1314         msg->index    = index;
1315         msg->protocol = protocol;
1316         msg->size     = size;
1317         memcpy(msg + 1, body, size);
1318
1319         return (dest->write(&buf[0], buf_size) == buf_size);
1320 }
1321
1322 bool
1323 LV2Plugin::write_from_ui(uint32_t       index,
1324                          uint32_t       protocol,
1325                          uint32_t       size,
1326                          const uint8_t* body)
1327 {
1328         if (!_from_ui) {
1329                 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1330                 /* buffer data communication from plugin UI to plugin instance.
1331                  * this buffer needs to potentially hold
1332                  *   (port's minimumSize) * (audio-periods) / (UI-periods)
1333                  * bytes.
1334                  *
1335                  *  e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1336                  *  ui-periods = 25 Hz (SuperRapidScreenUpdate)
1337                  *  default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1338                  *
1339                  * it is NOT safe to overflow (msg.size will be misinterpreted)
1340                  */
1341                 uint32_t bufsiz = 32768;
1342                 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1343                         bufsiz =  lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1344                 }
1345                 rbs = max((size_t) bufsiz * 8, rbs);
1346                 _from_ui = new RingBuffer<uint8_t>(rbs);
1347         }
1348
1349         if (!write_to(_from_ui, index, protocol, size, body)) {
1350                 error << "Error writing from UI to plugin" << endmsg;
1351                 return false;
1352         }
1353         return true;
1354 }
1355
1356 bool
1357 LV2Plugin::write_to_ui(uint32_t       index,
1358                        uint32_t       protocol,
1359                        uint32_t       size,
1360                        const uint8_t* body)
1361 {
1362         if (!write_to(_to_ui, index, protocol, size, body)) {
1363                 error << "Error writing from plugin to UI" << endmsg;
1364                 return false;
1365         }
1366         return true;
1367 }
1368
1369 static void
1370 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1371 {
1372         switch (value.type()) {
1373         case Variant::NOTHING:
1374                 break;
1375         case Variant::BEATS:
1376                 // No atom type for this, just forge a double
1377                 lv2_atom_forge_double(forge, value.get_beats().to_double());
1378                 break;
1379         case Variant::BOOL:
1380                 lv2_atom_forge_bool(forge, value.get_bool());
1381                 break;
1382         case Variant::DOUBLE:
1383                 lv2_atom_forge_double(forge, value.get_double());
1384                 break;
1385         case Variant::FLOAT:
1386                 lv2_atom_forge_float(forge, value.get_float());
1387                 break;
1388         case Variant::INT:
1389                 lv2_atom_forge_int(forge, value.get_int());
1390                 break;
1391         case Variant::LONG:
1392                 lv2_atom_forge_long(forge, value.get_long());
1393                 break;
1394         case Variant::PATH:
1395                 lv2_atom_forge_path(
1396                         forge, value.get_path().c_str(), value.get_path().size());
1397                 break;
1398         case Variant::STRING:
1399                 lv2_atom_forge_string(
1400                         forge, value.get_string().c_str(), value.get_string().size());
1401                 break;
1402         case Variant::URI:
1403                 lv2_atom_forge_uri(
1404                         forge, value.get_uri().c_str(), value.get_uri().size());
1405                 break;
1406         }
1407 }
1408
1409 /** Get a variant type from a URI, return false iff no match found. */
1410 static bool
1411 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1412 {
1413         if (uri == LV2_ATOM__Bool) {
1414                 type = Variant::BOOL;
1415         } else if (uri == LV2_ATOM__Double) {
1416                 type = Variant::DOUBLE;
1417         } else if (uri == LV2_ATOM__Float) {
1418                 type = Variant::FLOAT;
1419         } else if (uri == LV2_ATOM__Int) {
1420                 type = Variant::INT;
1421         } else if (uri == LV2_ATOM__Long) {
1422                 type = Variant::LONG;
1423         } else if (uri == LV2_ATOM__Path) {
1424                 type = Variant::PATH;
1425         } else if (uri == LV2_ATOM__String) {
1426                 type = Variant::STRING;
1427         } else if (uri == LV2_ATOM__URI) {
1428                 type = Variant::URI;
1429         } else {
1430                 return false;
1431         }
1432         return true;
1433 }
1434
1435 void
1436 LV2Plugin::set_property(uint32_t key, const Variant& value)
1437 {
1438         if (_patch_port_in_index == (uint32_t)-1) {
1439                 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1440                 return;
1441         } else if (value.type() == Variant::NOTHING) {
1442                 error << "LV2: set_property called with void value" << endmsg;
1443                 return;
1444         }
1445
1446         // Set up forge to write to temporary buffer on the stack
1447         LV2_Atom_Forge*      forge = &_impl->ui_forge;
1448         LV2_Atom_Forge_Frame frame;
1449         uint8_t              buf[PATH_MAX];  // Ought to be enough for anyone...
1450
1451         lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1452
1453         // Serialize patch:Set message to set property
1454 #ifdef HAVE_LV2_1_10_0
1455         lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
1456         lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1457         lv2_atom_forge_urid(forge, key);
1458         lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1459 #else
1460         lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
1461         lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1462         lv2_atom_forge_urid(forge, key);
1463         lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1464 #endif
1465
1466         forge_variant(forge, value);
1467
1468         // Write message to UI=>Plugin ring
1469         const LV2_Atom* const atom = (const LV2_Atom*)buf;
1470         write_from_ui(_patch_port_in_index,
1471                       _uri_map.urids.atom_eventTransfer,
1472                       lv2_atom_total_size(atom),
1473                       (const uint8_t*)atom);
1474 }
1475
1476 const ParameterDescriptor&
1477 LV2Plugin::get_property_descriptor(uint32_t id) const
1478 {
1479         PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1480         if (p != _property_descriptors.end()) {
1481                 return p->second;
1482         }
1483         return Plugin::get_property_descriptor(id);
1484 }
1485
1486 static void
1487 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1488 {
1489         if (lilv_nodes_contains(units, _world.units_midiNote)) {
1490                 desc.unit = ParameterDescriptor::MIDI_NOTE;
1491         } else if (lilv_nodes_contains(units, _world.units_db)) {
1492                 desc.unit = ParameterDescriptor::DB;
1493         } else if (lilv_nodes_contains(units, _world.units_hz)) {
1494                 desc.unit = ParameterDescriptor::HZ;
1495         }
1496         if (lilv_nodes_size(units) > 0) {
1497                 const LilvNode* unit = lilv_nodes_get_first(units);
1498                 LilvNode* render = get_value(lworld, unit, _world.units_render);
1499                 if (render) {
1500                         desc.print_fmt = lilv_node_as_string(render);
1501                         lilv_node_free(render);
1502                 }
1503         }
1504 }
1505
1506 static void
1507 load_parameter_descriptor(LV2World&            world,
1508                           ParameterDescriptor& desc,
1509                           Variant::Type        datatype,
1510                           const LilvNode*      subject)
1511 {
1512         LilvWorld* lworld  = _world.world;
1513         LilvNode*  label   = get_value(lworld, subject, _world.rdfs_label);
1514         LilvNode*  def     = get_value(lworld, subject, _world.lv2_default);
1515         LilvNode*  minimum = get_value(lworld, subject, _world.lv2_minimum);
1516         LilvNode*  maximum = get_value(lworld, subject, _world.lv2_maximum);
1517         LilvNodes* units   = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1518         if (label) {
1519                 desc.label = lilv_node_as_string(label);
1520         }
1521         if (def && lilv_node_is_float(def)) {
1522                 desc.normal = lilv_node_as_float(def);
1523         }
1524         if (minimum && lilv_node_is_float(minimum)) {
1525                 desc.lower = lilv_node_as_float(minimum);
1526         }
1527         if (maximum && lilv_node_is_float(maximum)) {
1528                 desc.upper = lilv_node_as_float(maximum);
1529         }
1530         load_parameter_descriptor_units(lworld, desc, units);
1531         desc.datatype      = datatype;
1532         desc.toggled      |= datatype == Variant::BOOL;
1533         desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1534         desc.update_steps();
1535
1536         lilv_nodes_free(units);
1537         lilv_node_free(label);
1538         lilv_node_free(def);
1539         lilv_node_free(minimum);
1540         lilv_node_free(maximum);
1541 }
1542
1543 void
1544 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1545 {
1546         LilvWorld*       lworld     = _world.world;
1547         const LilvNode*  subject    = lilv_plugin_get_uri(_impl->plugin);
1548         LilvNodes*       properties = lilv_world_find_nodes(
1549                 lworld, subject, _world.patch_writable, NULL);
1550         LILV_FOREACH(nodes, p, properties) {
1551                 // Get label and range
1552                 const LilvNode* prop  = lilv_nodes_get(properties, p);
1553                 LilvNode*       range = get_value(lworld, prop, _world.rdfs_range);
1554                 if (!range) {
1555                         warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1556                                                   lilv_node_as_uri(prop)) << endmsg;
1557                         continue;
1558                 }
1559
1560                 // Convert range to variant type (TODO: support for multiple range types)
1561                 Variant::Type datatype;
1562                 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1563                         error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1564                                                 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1565                         continue;
1566                 }
1567
1568                 // Add description to result
1569                 ParameterDescriptor desc;
1570                 desc.key      = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1571                 desc.datatype = datatype;
1572                 load_parameter_descriptor(_world, desc, datatype, prop);
1573                 descs.insert(std::make_pair(desc.key, desc));
1574
1575                 lilv_node_free(range);
1576         }
1577         lilv_nodes_free(properties);
1578 }
1579
1580 void
1581 LV2Plugin::announce_property_values()
1582 {
1583         if (_patch_port_in_index == (uint32_t)-1) {
1584                 return;
1585         }
1586
1587         // Set up forge to write to temporary buffer on the stack
1588         LV2_Atom_Forge*      forge = &_impl->ui_forge;
1589         LV2_Atom_Forge_Frame frame;
1590         uint8_t              buf[PATH_MAX];  // Ought to be enough for anyone...
1591
1592         lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1593
1594         // Serialize patch:Get message with no subject (implicitly plugin instance)
1595 #ifdef HAVE_LV2_1_10_0
1596         lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
1597 #else
1598         lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
1599 #endif
1600
1601         // Write message to UI=>Plugin ring
1602         const LV2_Atom* const atom = (const LV2_Atom*)buf;
1603         write_from_ui(_patch_port_in_index,
1604                       _uri_map.urids.atom_eventTransfer,
1605                       lv2_atom_total_size(atom),
1606                       (const uint8_t*)atom);
1607 }
1608
1609 void
1610 LV2Plugin::enable_ui_emission()
1611 {
1612         if (!_to_ui) {
1613                 /* see note in LV2Plugin::write_from_ui() */
1614                 uint32_t bufsiz = 32768;
1615                 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1616                         bufsiz =  lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1617                 }
1618                 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1619                 rbs = max((size_t) bufsiz * 8, rbs);
1620                 _to_ui = new RingBuffer<uint8_t>(rbs);
1621         }
1622 }
1623
1624 void
1625 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1626 {
1627         if (!_to_ui) {
1628                 return;
1629         }
1630
1631         uint32_t read_space = _to_ui->read_space();
1632         while (read_space > sizeof(UIMessage)) {
1633                 UIMessage msg;
1634                 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1635                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1636                         break;
1637                 }
1638                 vector<uint8_t> body(msg.size);
1639                 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1640                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1641                         break;
1642                 }
1643
1644                 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1645
1646                 read_space -= sizeof(msg) + msg.size;
1647         }
1648 }
1649
1650 int
1651 LV2Plugin::work(uint32_t size, const void* data)
1652 {
1653         return _impl->work_iface->work(
1654                 _impl->instance->lv2_handle, work_respond, this, size, data);
1655 }
1656
1657 int
1658 LV2Plugin::work_response(uint32_t size, const void* data)
1659 {
1660         return _impl->work_iface->work_response(
1661                 _impl->instance->lv2_handle, size, data);
1662 }
1663
1664 void
1665 LV2Plugin::set_insert_id(PBD::ID id)
1666 {
1667         if (_insert_id == "0") {
1668                 _insert_id = id;
1669         } else if (_insert_id != id) {
1670                 lilv_state_free(_impl->state);
1671                 _impl->state = NULL;
1672                 _insert_id   = id;
1673         }
1674 }
1675
1676 int
1677 LV2Plugin::set_state(const XMLNode& node, int version)
1678 {
1679         XMLNodeList          nodes;
1680         const XMLProperty*   prop;
1681         XMLNodeConstIterator iter;
1682         XMLNode*             child;
1683         const char*          sym;
1684         const char*          value;
1685         uint32_t             port_id;
1686         LocaleGuard          lg(X_("C"));
1687
1688         if (node.name() != state_node_name()) {
1689                 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1690                 return -1;
1691         }
1692
1693 #ifndef NO_PLUGIN_STATE
1694
1695         if (version < 3000) {
1696                 nodes = node.children("port");
1697         } else {
1698                 nodes = node.children("Port");
1699         }
1700
1701         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1702
1703                 child = *iter;
1704
1705                 if ((prop = child->property("symbol")) != 0) {
1706                         sym = prop->value().c_str();
1707                 } else {
1708                         warning << _("LV2: port has no symbol, ignored") << endmsg;
1709                         continue;
1710                 }
1711
1712                 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1713
1714                 if (i != _port_indices.end()) {
1715                         port_id = i->second;
1716                 } else {
1717                         warning << _("LV2: port has unknown index, ignored") << endmsg;
1718                         continue;
1719                 }
1720
1721                 if ((prop = child->property("value")) != 0) {
1722                         value = prop->value().c_str();
1723                 } else {
1724                         warning << _("LV2: port has no value, ignored") << endmsg;
1725                         continue;
1726                 }
1727
1728                 set_parameter(port_id, atof(value));
1729         }
1730
1731         _state_version = 0;
1732         if ((prop = node.property("state-dir")) != 0) {
1733                 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1734                         error << string_compose(
1735                                 "LV2: failed to parse state version from \"%1\"",
1736                                 prop->value()) << endmsg;
1737                 }
1738
1739                 std::string state_file = Glib::build_filename(
1740                         plugin_dir(),
1741                         Glib::build_filename(prop->value(), "state.ttl"));
1742
1743                 LilvState* state = lilv_state_new_from_file(
1744                         _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1745
1746                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1747                 lilv_state_free(_impl->state);
1748                 _impl->state = state;
1749         }
1750
1751         latency_compute_run();
1752 #endif
1753
1754         return Plugin::set_state(node, version);
1755 }
1756
1757 int
1758 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1759 {
1760         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1761         if (!port) {
1762                 error << string_compose("LV2: get descriptor of non-existent port %1", which)
1763                       << endmsg;
1764                 return 1;
1765         }
1766
1767         LilvNodes* portunits;
1768         LilvNode *def, *min, *max;
1769         lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1770         portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
1771
1772         // TODO: Once we can rely on lilv 0.18.0 being present,
1773         // load_parameter_descriptor() can be used for ports as well
1774         desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1775         desc.toggled      = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1776         desc.logarithmic  = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1777         desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1778         desc.label        = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1779         desc.normal       = def ? lilv_node_as_float(def) : 0.0f;
1780         desc.lower        = min ? lilv_node_as_float(min) : 0.0f;
1781         desc.upper        = max ? lilv_node_as_float(max) : 1.0f;
1782         load_parameter_descriptor_units(_world.world, desc, portunits);
1783
1784         if (desc.sr_dependent) {
1785                 desc.lower *= _session.frame_rate ();
1786                 desc.upper *= _session.frame_rate ();
1787         }
1788
1789         desc.min_unbound  = false; // TODO: LV2 extension required
1790         desc.max_unbound  = false; // TODO: LV2 extension required
1791
1792         desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1793         desc.scale_points = get_scale_points(which);
1794
1795         desc.update_steps();
1796
1797         lilv_node_free(def);
1798         lilv_node_free(min);
1799         lilv_node_free(max);
1800         lilv_nodes_free(portunits);
1801
1802         return 0;
1803 }
1804
1805 string
1806 LV2Plugin::describe_parameter(Evoral::Parameter which)
1807 {
1808         if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1809
1810                 if (lilv_port_has_property(_impl->plugin,
1811                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1812                         return X_("hidden");
1813                 }
1814
1815                 if (lilv_port_has_property(_impl->plugin,
1816                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1817                         return X_("hidden");
1818                 }
1819
1820                 if (lilv_port_has_property(_impl->plugin,
1821                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1822                         return X_("latency");
1823                 }
1824
1825                 LilvNode* name = lilv_port_get_name(_impl->plugin,
1826                                                     lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1827                 string ret(lilv_node_as_string(name));
1828                 lilv_node_free(name);
1829                 return ret;
1830         } else {
1831                 return "??";
1832         }
1833 }
1834
1835 framecnt_t
1836 LV2Plugin::signal_latency() const
1837 {
1838         if (_latency_control_port) {
1839                 return (framecnt_t)floor(*_latency_control_port);
1840         } else {
1841                 return 0;
1842         }
1843 }
1844
1845 set<Evoral::Parameter>
1846 LV2Plugin::automatable() const
1847 {
1848         set<Evoral::Parameter> ret;
1849
1850         for (uint32_t i = 0; i < parameter_count(); ++i) {
1851                 if (parameter_is_input(i) && parameter_is_control(i)) {
1852                         ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1853                 }
1854         }
1855
1856         for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
1857              p != _property_descriptors.end();
1858              ++p) {
1859                 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
1860         }
1861         return ret;
1862 }
1863
1864 void
1865 LV2Plugin::activate()
1866 {
1867         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1868
1869         if (!_was_activated) {
1870                 lilv_instance_activate(_impl->instance);
1871                 _was_activated = true;
1872         }
1873 }
1874
1875 void
1876 LV2Plugin::deactivate()
1877 {
1878         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1879
1880         if (_was_activated) {
1881                 lilv_instance_deactivate(_impl->instance);
1882                 _was_activated = false;
1883         }
1884 }
1885
1886 void
1887 LV2Plugin::cleanup()
1888 {
1889         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1890
1891         activate();
1892         deactivate();
1893         lilv_instance_free(_impl->instance);
1894         _impl->instance = NULL;
1895 }
1896
1897 void
1898 LV2Plugin::allocate_atom_event_buffers()
1899 {
1900         /* reserve local scratch buffers for ATOM event-queues */
1901         const LilvPlugin* p = _impl->plugin;
1902
1903         /* count non-MIDI atom event-ports
1904          * TODO: nicely ask drobilla to make a lilv_ call for that
1905          */
1906         int count_atom_out = 0;
1907         int count_atom_in = 0;
1908         int minimumSize = 32768; // TODO use a per-port minimum-size
1909         for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1910                 const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
1911                 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1912                         LilvNodes* buffer_types = lilv_port_get_value(
1913                                 p, port, _world.atom_bufferType);
1914                         LilvNodes* atom_supports = lilv_port_get_value(
1915                                 p, port, _world.atom_supports);
1916
1917                         if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1918                                         || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1919                                 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1920                                         count_atom_in++;
1921                                 }
1922                                 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1923                                         count_atom_out++;
1924                                 }
1925                                 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1926                                 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1927                                 if (min_size && lilv_node_is_int(min_size)) {
1928                                         minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1929                                 }
1930                                 lilv_nodes_free(min_size_v);
1931                         }
1932                         lilv_nodes_free(buffer_types);
1933                         lilv_nodes_free(atom_supports);
1934                 }
1935         }
1936
1937         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1938                                 name(), count_atom_in, count_atom_out));
1939
1940         const int total_atom_buffers = (count_atom_in + count_atom_out);
1941         if (_atom_ev_buffers || total_atom_buffers == 0) {
1942                 return;
1943         }
1944
1945         DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %d bytes\n", total_atom_buffers, minimumSize));
1946         _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1947         for (int i = 0; i < total_atom_buffers; ++i ) {
1948                 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1949                                 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
1950         }
1951         _atom_ev_buffers[total_atom_buffers] = 0;
1952         return;
1953 }
1954
1955 /** Write an ardour position/time/tempo/meter as an LV2 event.
1956  * @return true on success.
1957  */
1958 static bool
1959 write_position(LV2_Atom_Forge*     forge,
1960                LV2_Evbuf*          buf,
1961                const TempoMetric&  t,
1962                Timecode::BBT_Time& bbt,
1963                double              speed,
1964                framepos_t          position,
1965                framecnt_t          offset)
1966 {
1967         const URIMap::URIDs& urids = URIMap::instance().urids;
1968
1969         uint8_t pos_buf[256];
1970         lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1971         LV2_Atom_Forge_Frame frame;
1972 #ifdef HAVE_LV2_1_10_0
1973         lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
1974         lv2_atom_forge_key(forge, urids.time_frame);
1975         lv2_atom_forge_long(forge, position);
1976         lv2_atom_forge_key(forge, urids.time_speed);
1977         lv2_atom_forge_float(forge, speed);
1978         lv2_atom_forge_key(forge, urids.time_barBeat);
1979         lv2_atom_forge_float(forge, bbt.beats - 1 +
1980                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1981         lv2_atom_forge_key(forge, urids.time_bar);
1982         lv2_atom_forge_long(forge, bbt.bars - 1);
1983         lv2_atom_forge_key(forge, urids.time_beatUnit);
1984         lv2_atom_forge_int(forge, t.meter().note_divisor());
1985         lv2_atom_forge_key(forge, urids.time_beatsPerBar);
1986         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1987         lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
1988         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1989 #else
1990         lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
1991         lv2_atom_forge_property_head(forge, urids.time_frame, 0);
1992         lv2_atom_forge_long(forge, position);
1993         lv2_atom_forge_property_head(forge, urids.time_speed, 0);
1994         lv2_atom_forge_float(forge, speed);
1995         lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
1996         lv2_atom_forge_float(forge, bbt.beats - 1 +
1997                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1998         lv2_atom_forge_property_head(forge, urids.time_bar, 0);
1999         lv2_atom_forge_long(forge, bbt.bars - 1);
2000         lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2001         lv2_atom_forge_int(forge, t.meter().note_divisor());
2002         lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2003         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2004         lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2005         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
2006 #endif
2007
2008         LV2_Evbuf_Iterator    end  = lv2_evbuf_end(buf);
2009         const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2010         return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2011                                (const uint8_t*)(atom + 1));
2012 }
2013
2014 int
2015 LV2Plugin::connect_and_run(BufferSet& bufs,
2016         ChanMapping in_map, ChanMapping out_map,
2017         pframes_t nframes, framecnt_t offset)
2018 {
2019         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2020         Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
2021
2022         cycles_t then = get_cycles();
2023
2024         TempoMap&               tmap     = _session.tempo_map();
2025         Metrics::const_iterator metric_i = tmap.metrics_end();
2026         TempoMetric             tmetric  = tmap.metric_at(_session.transport_frame(), &metric_i);
2027
2028         if (_freewheel_control_port) {
2029                 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2030         }
2031
2032         if (_bpm_control_port) {
2033                 *_bpm_control_port = tmetric.tempo().beats_per_minute();
2034         }
2035
2036         ChanCount bufs_count;
2037         bufs_count.set(DataType::AUDIO, 1);
2038         bufs_count.set(DataType::MIDI, 1);
2039         BufferSet& silent_bufs  = _session.get_silent_buffers(bufs_count);
2040         BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2041         uint32_t const num_ports = parameter_count();
2042         uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2043
2044         uint32_t audio_in_index  = 0;
2045         uint32_t audio_out_index = 0;
2046         uint32_t midi_in_index   = 0;
2047         uint32_t midi_out_index  = 0;
2048         uint32_t atom_port_index = 0;
2049         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2050                 void*     buf   = NULL;
2051                 uint32_t  index = nil_index;
2052                 PortFlags flags = _port_flags[port_index];
2053                 bool      valid = false;
2054                 if (flags & PORT_AUDIO) {
2055                         if (flags & PORT_INPUT) {
2056                                 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2057                                 buf = (valid)
2058                                         ? bufs.get_audio(index).data(offset)
2059                                         : silent_bufs.get_audio(0).data(offset);
2060                         } else {
2061                                 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2062                                 buf = (valid)
2063                                         ? bufs.get_audio(index).data(offset)
2064                                         : scratch_bufs.get_audio(0).data(offset);
2065                         }
2066                 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2067                         /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2068                            be necessary, but the mapping is illegal in some cases.  Ideally
2069                            that should be fixed, but this is easier...
2070                         */
2071                         if (flags & PORT_MIDI) {
2072                                 if (flags & PORT_INPUT) {
2073                                         index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2074                                 } else {
2075                                         index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2076                                 }
2077                                 if (valid && bufs.count().n_midi() > index) {
2078                                         /* Note, ensure_lv2_bufsize() is not RT safe!
2079                                          * However free()/alloc() is only called if a
2080                                          * plugin requires a rsz:minimumSize buffersize
2081                                          * and the existing buffer if smaller.
2082                                          */
2083                                         bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2084                                         _ev_buffers[port_index] = bufs.get_lv2_midi(
2085                                                 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2086                                 }
2087                         } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2088                                 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2089                                 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2090                                 valid                   = true;
2091                         }
2092
2093                         if (valid && (flags & PORT_INPUT)) {
2094                                 Timecode::BBT_Time bbt;
2095                                 if ((flags & PORT_POSITION)) {
2096                                         if (_session.transport_frame() != _next_cycle_start ||
2097                                             _session.transport_speed() != _next_cycle_speed) {
2098                                                 // Transport has changed, write position at cycle start
2099                                                 tmap.bbt_time(_session.transport_frame(), bbt);
2100                                                 write_position(&_impl->forge, _ev_buffers[port_index],
2101                                                                tmetric, bbt, _session.transport_speed(),
2102                                                                _session.transport_frame(), 0);
2103                                         }
2104                                 }
2105
2106                                 // Get MIDI iterator range (empty range if no MIDI)
2107                                 MidiBuffer::iterator m = (index != nil_index)
2108                                         ? bufs.get_midi(index).begin()
2109                                         : silent_bufs.get_midi(0).end();
2110                                 MidiBuffer::iterator m_end = (index != nil_index)
2111                                         ? bufs.get_midi(index).end()
2112                                         : m;
2113
2114                                 // Now merge MIDI and any transport events into the buffer
2115                                 const uint32_t     type = _uri_map.urids.midi_MidiEvent;
2116                                 const framepos_t   tend = _session.transport_frame() + nframes;
2117                                 ++metric_i;
2118                                 while (m != m_end || (metric_i != tmap.metrics_end() &&
2119                                                       (*metric_i)->frame() < tend)) {
2120                                         MetricSection* metric = (metric_i != tmap.metrics_end())
2121                                                 ? *metric_i : NULL;
2122                                         if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2123                                                 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
2124                                                 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2125                                                 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2126                                                 ++m;
2127                                         } else {
2128                                                 tmetric.set_metric(metric);
2129                                                 bbt = metric->start();
2130                                                 write_position(&_impl->forge, _ev_buffers[port_index],
2131                                                                tmetric, bbt, _session.transport_speed(),
2132                                                                metric->frame(),
2133                                                                metric->frame() - _session.transport_frame());
2134                                                 ++metric_i;
2135                                         }
2136                                 }
2137                         } else if (!valid) {
2138                                 // Nothing we understand or care about, connect to scratch
2139                                 // see note for midi-buffer size above
2140                                 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2141                                                 0, _port_minimumSize[port_index]);
2142                                 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2143                                         (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2144                         }
2145
2146                         buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2147                 } else {
2148                         continue;  // Control port, leave buffer alone
2149                 }
2150                 lilv_instance_connect_port(_impl->instance, port_index, buf);
2151         }
2152
2153         // Read messages from UI and push into appropriate buffers
2154         if (_from_ui) {
2155                 uint32_t read_space = _from_ui->read_space();
2156                 while (read_space > sizeof(UIMessage)) {
2157                         UIMessage msg;
2158                         if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2159                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2160                                 break;
2161                         }
2162                         vector<uint8_t> body(msg.size);
2163                         if (_from_ui->read(&body[0], msg.size) != msg.size) {
2164                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2165                                 break;
2166                         }
2167                         if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2168                                 LV2_Evbuf*            buf  = _ev_buffers[msg.index];
2169                                 LV2_Evbuf_Iterator    i    = lv2_evbuf_end(buf);
2170                                 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2171                                 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2172                                                 (const uint8_t*)(atom + 1))) {
2173                                         error << "Failed to write data to LV2 event buffer\n";
2174                                 }
2175                         } else {
2176                                 error << "Received unknown message type from UI" << endmsg;
2177                         }
2178                         read_space -= sizeof(UIMessage) + msg.size;
2179                 }
2180         }
2181
2182         run(nframes);
2183
2184         midi_out_index = 0;
2185         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2186                 PortFlags flags = _port_flags[port_index];
2187                 bool      valid = false;
2188
2189                 /* TODO ask drobilla about comment
2190                  * "Make Ardour event buffers generic so plugins can communicate"
2191                  * in libs/ardour/buffer_set.cc:310
2192                  *
2193                  * ideally the user could choose which of the following two modes
2194                  * to use (e.g. instrument/effect chains  MIDI OUT vs MIDI TRHU).
2195                  *
2196                  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2197                  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2198                  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2199                  *                            for quite a while at least ;)
2200                  */
2201                 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2202                 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2203                         const uint32_t buf_index = out_map.get(
2204                                 DataType::MIDI, midi_out_index++, &valid);
2205                         if (valid) {
2206                                 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2207                         }
2208                 }
2209                 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2210                 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2211                         const uint32_t buf_index = out_map.get(
2212                                 DataType::MIDI, midi_out_index++, &valid);
2213                         if (valid) {
2214                                 bufs.flush_lv2_midi(true, buf_index);
2215                         }
2216                 }
2217
2218
2219                 // Write messages to UI
2220                 if ((_to_ui || _patch_port_out_index != (uint32_t)-1) &&
2221                     (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2222                         LV2_Evbuf* buf = _ev_buffers[port_index];
2223                         for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2224                              lv2_evbuf_is_valid(i);
2225                              i = lv2_evbuf_next(i)) {
2226                                 uint32_t frames, subframes, type, size;
2227                                 uint8_t* data;
2228                                 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2229
2230                                 // Intercept patch change messages to emit PropertyChanged signal
2231                                 if ((flags & PORT_PATCHMSG)) {
2232                                         LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2233                                         if (atom->type == _uri_map.urids.atom_Blank ||
2234                                             atom->type == _uri_map.urids.atom_Object) {
2235                                                 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2236                                                 if (obj->body.otype == _uri_map.urids.patch_Set) {
2237                                                         const LV2_Atom* property = NULL;
2238                                                         const LV2_Atom* value    = NULL;
2239                                                         lv2_atom_object_get(obj,
2240                                                                             _uri_map.urids.patch_property, &property,
2241                                                                             _uri_map.urids.patch_value,    &value,
2242                                                                             0);
2243
2244                                                         if (!property || !value ||
2245                                                             property->type != _uri_map.urids.atom_URID ||
2246                                                             value->type    != _uri_map.urids.atom_Path) {
2247                                                                 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2248                                                                 continue;
2249                                                         }
2250
2251                                                         const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2252                                                         const char*    path    = (const char*)LV2_ATOM_BODY_CONST(value);
2253
2254                                                         // Emit PropertyChanged signal for UI
2255                                                         // TODO: This should emit the control's Changed signal
2256                                                         PropertyChanged(prop_id, Variant(Variant::PATH, path));
2257                                                 }
2258                                         }
2259                                 }
2260
2261                                 if (!_to_ui) continue;
2262                                 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2263                                             size + sizeof(LV2_Atom),
2264                                             data - sizeof(LV2_Atom));
2265                         }
2266                 }
2267         }
2268
2269         cycles_t now = get_cycles();
2270         set_cycles((uint32_t)(now - then));
2271
2272         // Update expected transport information for next cycle so we can detect changes
2273         _next_cycle_speed = _session.transport_speed();
2274         _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
2275
2276         return 0;
2277 }
2278
2279 bool
2280 LV2Plugin::parameter_is_control(uint32_t param) const
2281 {
2282         assert(param < _port_flags.size());
2283         return _port_flags[param] & PORT_CONTROL;
2284 }
2285
2286 bool
2287 LV2Plugin::parameter_is_audio(uint32_t param) const
2288 {
2289         assert(param < _port_flags.size());
2290         return _port_flags[param] & PORT_AUDIO;
2291 }
2292
2293 bool
2294 LV2Plugin::parameter_is_event(uint32_t param) const
2295 {
2296         assert(param < _port_flags.size());
2297         return _port_flags[param] & PORT_EVENT;
2298 }
2299
2300 bool
2301 LV2Plugin::parameter_is_output(uint32_t param) const
2302 {
2303         assert(param < _port_flags.size());
2304         return _port_flags[param] & PORT_OUTPUT;
2305 }
2306
2307 bool
2308 LV2Plugin::parameter_is_input(uint32_t param) const
2309 {
2310         assert(param < _port_flags.size());
2311         return _port_flags[param] & PORT_INPUT;
2312 }
2313
2314 void
2315 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2316 {
2317         if (buf && len) {
2318                 if (param < parameter_count()) {
2319                         snprintf(buf, len, "%.3f", get_parameter(param));
2320                 } else {
2321                         strcat(buf, "0");
2322                 }
2323         }
2324 }
2325
2326 boost::shared_ptr<ScalePoints>
2327 LV2Plugin::get_scale_points(uint32_t port_index) const
2328 {
2329         const LilvPort*  port   = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2330         LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2331
2332         boost::shared_ptr<ScalePoints> ret;
2333         if (!points) {
2334                 return ret;
2335         }
2336
2337         ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
2338
2339         LILV_FOREACH(scale_points, i, points) {
2340                 const LilvScalePoint* p     = lilv_scale_points_get(points, i);
2341                 const LilvNode*       label = lilv_scale_point_get_label(p);
2342                 const LilvNode*       value = lilv_scale_point_get_value(p);
2343                 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
2344                         ret->insert(make_pair(lilv_node_as_string(label),
2345                                               lilv_node_as_float(value)));
2346                 }
2347         }
2348
2349         lilv_scale_points_free(points);
2350         return ret;
2351 }
2352
2353 void
2354 LV2Plugin::run(pframes_t nframes)
2355 {
2356         uint32_t const N = parameter_count();
2357         for (uint32_t i = 0; i < N; ++i) {
2358                 if (parameter_is_control(i) && parameter_is_input(i)) {
2359                         _control_data[i] = _shadow_data[i];
2360                 }
2361         }
2362
2363         lilv_instance_run(_impl->instance, nframes);
2364
2365         if (_impl->work_iface) {
2366                 _worker->emit_responses();
2367                 if (_impl->work_iface->end_run) {
2368                         _impl->work_iface->end_run(_impl->instance->lv2_handle);
2369                 }
2370         }
2371 }
2372
2373 void
2374 LV2Plugin::latency_compute_run()
2375 {
2376         if (!_latency_control_port) {
2377                 return;
2378         }
2379
2380         // Run the plugin so that it can set its latency parameter
2381
2382         bool was_activated = _was_activated;
2383         activate();
2384
2385         uint32_t port_index = 0;
2386         uint32_t in_index   = 0;
2387         uint32_t out_index  = 0;
2388
2389         // this is done in the main thread. non realtime.
2390         const framecnt_t bufsize = _engine.samples_per_cycle();
2391         float            *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
2392
2393         memset(buffer, 0, sizeof(float) * bufsize);
2394
2395         // FIXME: Ensure plugins can handle in-place processing
2396
2397         port_index = 0;
2398
2399         while (port_index < parameter_count()) {
2400                 if (parameter_is_audio(port_index)) {
2401                         if (parameter_is_input(port_index)) {
2402                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2403                                 in_index++;
2404                         } else if (parameter_is_output(port_index)) {
2405                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
2406                                 out_index++;
2407                         }
2408                 }
2409                 port_index++;
2410         }
2411
2412         run(bufsize);
2413         deactivate();
2414         if (was_activated) {
2415                 activate();
2416         }
2417         free(buffer);
2418 }
2419
2420 const LilvPort*
2421 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
2422 {
2423         const LilvPort* port = NULL;
2424         LilvNode* designation = lilv_new_uri(_world.world, uri);
2425         port = lilv_plugin_get_port_by_designation(
2426                 plugin, _world.lv2_InputPort, designation);
2427         lilv_node_free(designation);
2428         if (port) {
2429                 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
2430         }
2431         return port;
2432 }
2433
2434 static bool lv2_filter (const string& str, void* /*arg*/)
2435 {
2436         /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
2437
2438         return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
2439 }
2440
2441
2442 LV2World::LV2World()
2443         : world(lilv_world_new())
2444         , _bundle_checked(false)
2445 {
2446         atom_AtomPort      = lilv_new_uri(world, LV2_ATOM__AtomPort);
2447         atom_Chunk         = lilv_new_uri(world, LV2_ATOM__Chunk);
2448         atom_Sequence      = lilv_new_uri(world, LV2_ATOM__Sequence);
2449         atom_bufferType    = lilv_new_uri(world, LV2_ATOM__bufferType);
2450         atom_supports      = lilv_new_uri(world, LV2_ATOM__supports);
2451         atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
2452         ev_EventPort       = lilv_new_uri(world, LILV_URI_EVENT_PORT);
2453         ext_logarithmic    = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
2454         ext_notOnGUI       = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
2455         lv2_AudioPort      = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
2456         lv2_ControlPort    = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
2457         lv2_InputPort      = lilv_new_uri(world, LILV_URI_INPUT_PORT);
2458         lv2_OutputPort     = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
2459         lv2_inPlaceBroken  = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
2460         lv2_integer        = lilv_new_uri(world, LV2_CORE__integer);
2461         lv2_default        = lilv_new_uri(world, LV2_CORE__default);
2462         lv2_minimum        = lilv_new_uri(world, LV2_CORE__minimum);
2463         lv2_maximum        = lilv_new_uri(world, LV2_CORE__maximum);
2464         lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
2465         lv2_sampleRate     = lilv_new_uri(world, LV2_CORE__sampleRate);
2466         lv2_toggled        = lilv_new_uri(world, LV2_CORE__toggled);
2467         lv2_enumeration    = lilv_new_uri(world, LV2_CORE__enumeration);
2468         lv2_freewheeling   = lilv_new_uri(world, LV2_CORE__freeWheeling);
2469         midi_MidiEvent     = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
2470         rdfs_comment       = lilv_new_uri(world, LILV_NS_RDFS "comment");
2471         rdfs_label         = lilv_new_uri(world, LILV_NS_RDFS "label");
2472         rdfs_range         = lilv_new_uri(world, LILV_NS_RDFS "range");
2473         rsz_minimumSize    = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
2474         time_Position      = lilv_new_uri(world, LV2_TIME__Position);
2475         ui_GtkUI           = lilv_new_uri(world, LV2_UI__GtkUI);
2476         ui_external        = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
2477         ui_externalkx      = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
2478         units_unit         = lilv_new_uri(world, LV2_UNITS__unit);
2479         units_render       = lilv_new_uri(world, LV2_UNITS__render);
2480         units_hz           = lilv_new_uri(world, LV2_UNITS__hz);
2481         units_midiNote     = lilv_new_uri(world, LV2_UNITS__midiNote);
2482         units_db           = lilv_new_uri(world, LV2_UNITS__db);
2483         patch_writable     = lilv_new_uri(world, LV2_PATCH__writable);
2484         patch_Message      = lilv_new_uri(world, LV2_PATCH__Message);
2485         lv2_noSampleAccurateCtrl = lilv_new_uri(world, LV2_CORE_PREFIX "noSampleAccurateControls");
2486 #ifdef HAVE_LV2_1_2_0
2487         bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
2488         bufz_fixedBlockLength    = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
2489         bufz_nominalBlockLength  = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
2490 #endif
2491
2492 }
2493
2494 LV2World::~LV2World()
2495 {
2496 #ifdef HAVE_LV2_1_2_0
2497         lilv_node_free(bufz_nominalBlockLength);
2498         lilv_node_free(bufz_fixedBlockLength);
2499         lilv_node_free(bufz_powerOf2BlockLength);
2500 #endif
2501         lilv_node_free(lv2_noSampleAccurateCtrl);
2502         lilv_node_free(patch_Message);
2503         lilv_node_free(patch_writable);
2504         lilv_node_free(units_hz);
2505         lilv_node_free(units_midiNote);
2506         lilv_node_free(units_db);
2507         lilv_node_free(units_unit);
2508         lilv_node_free(units_render);
2509         lilv_node_free(ui_externalkx);
2510         lilv_node_free(ui_external);
2511         lilv_node_free(ui_GtkUI);
2512         lilv_node_free(time_Position);
2513         lilv_node_free(rsz_minimumSize);
2514         lilv_node_free(rdfs_comment);
2515         lilv_node_free(rdfs_label);
2516         lilv_node_free(rdfs_range);
2517         lilv_node_free(midi_MidiEvent);
2518         lilv_node_free(lv2_enumeration);
2519         lilv_node_free(lv2_freewheeling);
2520         lilv_node_free(lv2_toggled);
2521         lilv_node_free(lv2_sampleRate);
2522         lilv_node_free(lv2_reportsLatency);
2523         lilv_node_free(lv2_integer);
2524         lilv_node_free(lv2_inPlaceBroken);
2525         lilv_node_free(lv2_OutputPort);
2526         lilv_node_free(lv2_InputPort);
2527         lilv_node_free(lv2_ControlPort);
2528         lilv_node_free(lv2_AudioPort);
2529         lilv_node_free(ext_notOnGUI);
2530         lilv_node_free(ext_logarithmic);
2531         lilv_node_free(ev_EventPort);
2532         lilv_node_free(atom_supports);
2533         lilv_node_free(atom_eventTransfer);
2534         lilv_node_free(atom_bufferType);
2535         lilv_node_free(atom_Sequence);
2536         lilv_node_free(atom_Chunk);
2537         lilv_node_free(atom_AtomPort);
2538         lilv_world_free(world);
2539 }
2540
2541 void
2542 LV2World::load_bundled_plugins(bool verbose)
2543 {
2544         if (!_bundle_checked) {
2545                 if (verbose) {
2546                         cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
2547                 }
2548
2549                 vector<string> plugin_objects;
2550                 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
2551                 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
2552 #ifdef PLATFORM_WINDOWS
2553                         string uri = "file:///" + *x + "/";
2554 #else
2555                         string uri = "file://" + *x + "/";
2556 #endif
2557                         LilvNode *node = lilv_new_uri(world, uri.c_str());
2558                         lilv_world_load_bundle(world, node);
2559                         lilv_node_free(node);
2560                 }
2561
2562                 lilv_world_load_all(world);
2563                 _bundle_checked = true;
2564         }
2565 }
2566
2567 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
2568 {
2569         type = ARDOUR::LV2;
2570         _plugin_uri = strdup(plugin_uri);
2571 }
2572
2573 LV2PluginInfo::~LV2PluginInfo()
2574 {
2575         free(_plugin_uri);
2576         _plugin_uri = NULL;
2577 }
2578
2579 PluginPtr
2580 LV2PluginInfo::load(Session& session)
2581 {
2582         try {
2583                 PluginPtr plugin;
2584                 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2585                 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
2586                 if (!uri) { throw failed_constructor(); }
2587                 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
2588                 if (!lp) { throw failed_constructor(); }
2589                 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
2590                 lilv_node_free(uri);
2591                 plugin->set_info(PluginInfoPtr(shared_from_this ()));
2592                 return plugin;
2593         } catch (failed_constructor& err) {
2594                 return PluginPtr((Plugin*)0);
2595         }
2596
2597         return PluginPtr();
2598 }
2599
2600 bool
2601 LV2PluginInfo::in_category (const std::string &c) const
2602 {
2603         // TODO use untranslated lilv_plugin_get_class()
2604         // match gtk2_ardour/plugin_selector.cc
2605         if (category == c) {
2606                 return true;
2607         }
2608         return false;
2609 }
2610
2611 bool
2612 LV2PluginInfo::is_instrument () const
2613 {
2614         if (category == "Instrument") {
2615                 return true;
2616         }
2617 #if 1
2618         /* until we make sure that category remains untranslated in the lv2.ttl spec
2619          * and until most instruments also classify themselves as such, there's a 2nd check:
2620          */
2621         if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
2622                 return true;
2623         }
2624 #endif
2625         return false;
2626 }
2627
2628 PluginInfoList*
2629 LV2PluginInfo::discover()
2630 {
2631         LV2World world;
2632         world.load_bundled_plugins();
2633         _world.load_bundled_plugins(true);
2634
2635         PluginInfoList*    plugs   = new PluginInfoList;
2636         const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
2637
2638         LILV_FOREACH(plugins, i, plugins) {
2639                 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2640                 const LilvNode* pun = lilv_plugin_get_uri(p);
2641                 if (!pun) continue;
2642                 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
2643
2644                 LilvNode* name = lilv_plugin_get_name(p);
2645                 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2646                         warning << "Ignoring invalid LV2 plugin "
2647                                 << lilv_node_as_string(lilv_plugin_get_uri(p))
2648                                 << endmsg;
2649                         continue;
2650                 }
2651
2652                 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
2653                         warning << string_compose(
2654                             _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
2655                             lilv_node_as_string(name)) << endmsg;
2656                         lilv_node_free(name);
2657                         continue;
2658                 }
2659
2660 #ifdef HAVE_LV2_1_2_0
2661                 LilvNodes *required_features = lilv_plugin_get_required_features (p);
2662                 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
2663                                 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
2664                    ) {
2665                         warning << string_compose(
2666                             _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
2667                             lilv_node_as_string(name)) << endmsg;
2668                         lilv_nodes_free(required_features);
2669                         lilv_node_free(name);
2670                         continue;
2671                 }
2672                 lilv_nodes_free(required_features);
2673 #endif
2674
2675                 info->type = LV2;
2676
2677                 info->name = string(lilv_node_as_string(name));
2678                 lilv_node_free(name);
2679                 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
2680
2681                 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2682                 const LilvNode*        label  = lilv_plugin_class_get_label(pclass);
2683                 info->category = lilv_node_as_string(label);
2684
2685                 LilvNode* author_name = lilv_plugin_get_author_name(p);
2686                 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2687                 lilv_node_free(author_name);
2688
2689                 info->path = "/NOPATH"; // Meaningless for LV2
2690
2691                 /* count atom-event-ports that feature
2692                  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2693                  *
2694                  * TODO: nicely ask drobilla to make a lilv_ call for that
2695                  */
2696                 int count_midi_out = 0;
2697                 int count_midi_in = 0;
2698                 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2699                         const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
2700                         if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
2701                                 LilvNodes* buffer_types = lilv_port_get_value(
2702                                         p, port, world.atom_bufferType);
2703                                 LilvNodes* atom_supports = lilv_port_get_value(
2704                                         p, port, world.atom_supports);
2705
2706                                 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
2707                                                 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
2708                                         if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
2709                                                 count_midi_in++;
2710                                         }
2711                                         if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
2712                                                 count_midi_out++;
2713                                         }
2714                                 }
2715                                 lilv_nodes_free(buffer_types);
2716                                 lilv_nodes_free(atom_supports);
2717                         }
2718                 }
2719
2720                 info->n_inputs.set_audio(
2721                         lilv_plugin_get_num_ports_of_class(
2722                                 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
2723                 info->n_inputs.set_midi(
2724                         lilv_plugin_get_num_ports_of_class(
2725                                 p, world.lv2_InputPort, world.ev_EventPort, NULL)
2726                         + count_midi_in);
2727
2728                 info->n_outputs.set_audio(
2729                         lilv_plugin_get_num_ports_of_class(
2730                                 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
2731                 info->n_outputs.set_midi(
2732                         lilv_plugin_get_num_ports_of_class(
2733                                 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
2734                         + count_midi_out);
2735
2736                 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2737                 info->index     = 0; // Meaningless for LV2
2738
2739                 plugs->push_back(info);
2740         }
2741
2742         return plugs;
2743 }