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