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