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