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