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