libs/ardour/lv2_plugin.cc

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