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