libs/ardour/lv2_plugin.cc

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