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 <giomm/file.h>
  29 #include <glib/gprintf.h>
  30 #include <glibmm.h>
  31
  32 #include <boost/utility.hpp>
  33
  34 #include "pbd/pathscanner.h"
  35 #include "pbd/compose.h"
  36 #include "pbd/error.h"
  37 #include "pbd/xml++.h"
  38
  39 #include "libardour-config.h"
  40
  41 #include "ardour/audio_buffer.h"
  42 #include "ardour/audioengine.h"
  43 #include "ardour/debug.h"
  44 #include "ardour/lv2_plugin.h"
  45 #include "ardour/session.h"
  46 #include "ardour/tempo.h"
  47 #include "ardour/types.h"
  48 #include "ardour/utils.h"
  49 #include "ardour/worker.h"
  50 #include "ardour/lv2_bundled_search_path.h"
  51
  52 #include "i18n.h"
  53 #include <locale.h>
  54
  55 #include <lilv/lilv.h>
  56
  57 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
  58 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
  59 #include "lv2/lv2plug.in/ns/ext/log/log.h"
  60 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
  61 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
  62 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
  63 #include "lv2/lv2plug.in/ns/ext/state/state.h"
  64 #include "lv2/lv2plug.in/ns/ext/time/time.h"
  65 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
  66 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
  67 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
  68 #ifdef HAVE_NEW_LV2
  69 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
  70 #include "lv2/lv2plug.in/ns/ext/options/options.h"
  71 #endif
  72
  73 #include "lv2_evbuf.h"
  74
  75 #ifdef HAVE_SUIL
  76 #include <suil/suil.h>
  77 #endif
  78
  79 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
  80     This needs to be roughly the number of cycles the UI will get around to
  81     actually processing the traffic.  Lower values are flakier but save memory.
  82 */
  83 static const size_t NBUFS = 4;
  84
  85 using namespace std;
  86 using namespace ARDOUR;
  87 using namespace PBD;
  88
  89 URIMap LV2Plugin::_uri_map;
  90
  91 LV2Plugin::URIDs LV2Plugin::urids = {
  92         _uri_map.uri_to_id(LV2_ATOM__Chunk),
  93         _uri_map.uri_to_id(LV2_ATOM__Path),
  94         _uri_map.uri_to_id(LV2_ATOM__Sequence),
  95         _uri_map.uri_to_id(LV2_ATOM__eventTransfer),
  96         _uri_map.uri_to_id(LV2_LOG__Error),
  97         _uri_map.uri_to_id(LV2_LOG__Note),
  98         _uri_map.uri_to_id(LV2_LOG__Warning),
  99         _uri_map.uri_to_id(LV2_MIDI__MidiEvent),
 100         _uri_map.uri_to_id(LV2_TIME__Position),
 101         _uri_map.uri_to_id(LV2_TIME__bar),
 102         _uri_map.uri_to_id(LV2_TIME__barBeat),
 103         _uri_map.uri_to_id(LV2_TIME__beatUnit),
 104         _uri_map.uri_to_id(LV2_TIME__beatsPerBar),
 105         _uri_map.uri_to_id(LV2_TIME__beatsPerMinute),
 106         _uri_map.uri_to_id(LV2_TIME__frame),
 107         _uri_map.uri_to_id(LV2_TIME__speed)
 108 };
 109
 110 class LV2World : boost::noncopyable {
 111 public:
 112         LV2World ();
 113         ~LV2World ();
 114
 115         void load_bundled_plugins();
 116
 117         LilvWorld* world;
 118
 119         LilvNode* atom_AtomPort;
 120         LilvNode* atom_Chunk;
 121         LilvNode* atom_Sequence;
 122         LilvNode* atom_bufferType;
 123         LilvNode* atom_eventTransfer;
 124         LilvNode* atom_supports;
 125         LilvNode* ev_EventPort;
 126         LilvNode* ext_logarithmic;
 127         LilvNode* ext_notOnGUI;
 128         LilvNode* lv2_AudioPort;
 129         LilvNode* lv2_ControlPort;
 130         LilvNode* lv2_InputPort;
 131         LilvNode* lv2_OutputPort;
 132         LilvNode* lv2_enumeration;
 133         LilvNode* lv2_freewheeling;
 134         LilvNode* lv2_inPlaceBroken;
 135         LilvNode* lv2_integer;
 136         LilvNode* lv2_reportsLatency;
 137         LilvNode* lv2_sampleRate;
 138         LilvNode* lv2_toggled;
 139         LilvNode* midi_MidiEvent;
 140         LilvNode* rdfs_comment;
 141         LilvNode* rsz_minimumSize;
 142         LilvNode* time_Position;
 143         LilvNode* ui_GtkUI;
 144         LilvNode* ui_external;
 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 == LV2Plugin::urids.log_Error) {
 199                 error << str << endmsg;
 200         } else if (type == LV2Plugin::urids.log_Warning) {
 201                 warning << str << endmsg;
 202         } else if (type == LV2Plugin::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 };
 242
 243 LV2Plugin::LV2Plugin (AudioEngine& engine,
 244                       Session&     session,
 245                       const void*  c_plugin,
 246                       framecnt_t   rate)
 247         : Plugin (engine, session)
 248         , Workee ()
 249         , _impl(new Impl())
 250         , _features(NULL)
 251         , _worker(NULL)
 252         , _insert_id("0")
 253 {
 254         init(c_plugin, rate);
 255 }
 256
 257 LV2Plugin::LV2Plugin (const LV2Plugin& other)
 258         : Plugin (other)
 259         , Workee ()
 260         , _impl(new Impl())
 261         , _features(NULL)
 262         , _worker(NULL)
 263         , _insert_id(other._insert_id)
 264 {
 265         init(other._impl->plugin, other._sample_rate);
 266
 267         for (uint32_t i = 0; i < parameter_count(); ++i) {
 268                 _control_data[i] = other._shadow_data[i];
 269                 _shadow_data[i]  = other._shadow_data[i];
 270         }
 271 }
 272
 273 void
 274 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
 275 {
 276         DEBUG_TRACE(DEBUG::LV2, "init\n");
 277
 278         _impl->plugin           = (const LilvPlugin*)c_plugin;
 279         _impl->ui               = NULL;
 280         _impl->ui_type          = NULL;
 281         _to_ui                  = NULL;
 282         _from_ui                = NULL;
 283         _control_data           = 0;
 284         _shadow_data            = 0;
 285         _atom_ev_buffers        = 0;
 286         _ev_buffers             = 0;
 287         _bpm_control_port       = 0;
 288         _freewheel_control_port = 0;
 289         _latency_control_port   = 0;
 290         _next_cycle_start       = std::numeric_limits<framepos_t>::max();
 291         _next_cycle_speed       = 1.0;
 292         _block_length           = _engine.frames_per_cycle();
 293         _seq_size               = _engine.raw_buffer_size(DataType::MIDI);
 294         _state_version          = 0;
 295         _was_activated          = false;
 296         _has_state_interface    = false;
 297
 298         _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
 299         _data_access_feature.URI     = "http://lv2plug.in/ns/ext/data-access";
 300         _make_path_feature.URI       = LV2_STATE__makePath;
 301         _log_feature.URI             = LV2_LOG__log;
 302         _work_schedule_feature.URI   = LV2_WORKER__schedule;
 303         _work_schedule_feature.data  = NULL;
 304         _def_state_feature.URI       = LV2_STATE_PREFIX "loadDefaultState";  // Post LV2-1.2.0
 305         _def_state_feature.data      = NULL;
 306
 307         const LilvPlugin* plugin = _impl->plugin;
 308
 309         LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
 310         LilvNode* state_uri       = lilv_new_uri(_world.world, LV2_STATE_URI);
 311         _has_state_interface =
 312                 // What plugins should have (lv2:extensionData state:Interface)
 313                 lilv_plugin_has_extension_data(plugin, state_iface_uri)
 314                 // What some outdated/incorrect ones have
 315                 || lilv_plugin_has_feature(plugin, state_uri);
 316         lilv_node_free(state_uri);
 317         lilv_node_free(state_iface_uri);
 318
 319         _features    = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
 320         _features[0] = &_instance_access_feature;
 321         _features[1] = &_data_access_feature;
 322         _features[2] = &_make_path_feature;
 323         _features[3] = _uri_map.uri_map_feature();
 324         _features[4] = _uri_map.urid_map_feature();
 325         _features[5] = _uri_map.urid_unmap_feature();
 326         _features[6] = &_log_feature;
 327
 328         unsigned n_features = 7;
 329 #ifdef HAVE_NEW_LV2
 330         _features[n_features++] = &_def_state_feature;
 331 #endif
 332
 333         lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
 334
 335 #ifdef HAVE_NEW_LV2
 336         LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
 337         LV2_Options_Option options[] = {
 338                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
 339                   sizeof(int32_t), atom_Int, &_block_length },
 340                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
 341                   sizeof(int32_t), atom_Int, &_block_length },
 342                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
 343                   sizeof(int32_t), atom_Int, &_seq_size },
 344                 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
 345         };
 346
 347         _options_feature.URI    = LV2_OPTIONS__options;
 348         _options_feature.data   = options;
 349         _features[n_features++] = &_options_feature;
 350 #endif
 351
 352         LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
 353                 sizeof(LV2_State_Make_Path));
 354         make_path->handle = this;
 355         make_path->path = &lv2_state_make_path;
 356         _make_path_feature.data = make_path;
 357
 358         LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
 359         log->handle  = this;
 360         log->printf  = &log_printf;
 361         log->vprintf = &log_vprintf;
 362         _log_feature.data = log;
 363
 364         LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
 365         if (lilv_plugin_has_feature(plugin, worker_schedule)) {
 366                 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
 367                         sizeof(LV2_Worker_Schedule));
 368                 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
 369                 _worker                     = new Worker(this, buf_size);
 370                 schedule->handle            = this;
 371                 schedule->schedule_work     = work_schedule;
 372                 _work_schedule_feature.data = schedule;
 373                 _features[n_features++]     = &_work_schedule_feature;
 374         }
 375         lilv_node_free(worker_schedule);
 376
 377         _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
 378         _impl->name     = lilv_plugin_get_name(plugin);
 379         _impl->author   = lilv_plugin_get_author_name(plugin);
 380
 381         if (_impl->instance == 0) {
 382                 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
 383                 throw failed_constructor();
 384         }
 385
 386         _instance_access_feature.data              = (void*)_impl->instance->lv2_handle;
 387         _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
 388         _data_access_feature.data                  = &_data_access_extension_data;
 389
 390         LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
 391         if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
 392                 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
 393                         LV2_WORKER__interface);
 394         }
 395         lilv_node_free(worker_iface_uri);
 396
 397         if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
 398                 error << string_compose(
 399                     _("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
 400                     lilv_node_as_string(_impl->name)) << endmsg;
 401                 lilv_node_free(_impl->name);
 402                 lilv_node_free(_impl->author);
 403                 throw failed_constructor();
 404         }
 405
 406 #ifdef HAVE_NEW_LILV
 407         // Load default state
 408         LilvState* state = lilv_state_new_from_world(
 409                 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
 410         if (state && _has_state_interface) {
 411                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
 412         }
 413 #endif
 414
 415         _sample_rate = rate;
 416
 417         const uint32_t num_ports = this->num_ports();
 418         for (uint32_t i = 0; i < num_ports; ++i) {
 419                 const LilvPort* port  = lilv_plugin_get_port_by_index(_impl->plugin, i);
 420                 PortFlags       flags = 0;
 421                 size_t          minimumSize = 0;
 422
 423                 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
 424                         flags |= PORT_OUTPUT;
 425                 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
 426                         flags |= PORT_INPUT;
 427                 } else {
 428                         error << string_compose(
 429                                 "LV2: \"%1\" port %2 is neither input nor output",
 430                                 lilv_node_as_string(_impl->name), i) << endmsg;
 431                         throw failed_constructor();
 432                 }
 433
 434                 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
 435                         flags |= PORT_CONTROL;
 436                 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
 437                         flags |= PORT_AUDIO;
 438                 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
 439                         flags |= PORT_EVENT;
 440                         flags |= PORT_MIDI;  // We assume old event API ports are for MIDI
 441                 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
 442                         LilvNodes* buffer_types = lilv_port_get_value(
 443                                 _impl->plugin, port, _world.atom_bufferType);
 444                         LilvNodes* atom_supports = lilv_port_get_value(
 445                                 _impl->plugin, port, _world.atom_supports);
 446
 447                         if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
 448                                 flags |= PORT_SEQUENCE;
 449                                 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
 450                                         flags |= PORT_MIDI;
 451                                 }
 452                                 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
 453                                         flags |= PORT_POSITION;
 454                                 }
 455                         }
 456                         LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
 457                         LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
 458                         if (min_size && lilv_node_is_int(min_size)) {
 459                                 minimumSize = lilv_node_as_int(min_size);
 460                         }
 461                         lilv_nodes_free(min_size_v);
 462                         lilv_nodes_free(buffer_types);
 463                         lilv_nodes_free(atom_supports);
 464                 } else {
 465                         error << string_compose(
 466                                 "LV2: \"%1\" port %2 has no known data type",
 467                                 lilv_node_as_string(_impl->name), i) << endmsg;
 468                         throw failed_constructor();
 469                 }
 470
 471                 _port_flags.push_back(flags);
 472                 _port_minimumSize.push_back(minimumSize);
 473         }
 474
 475         _control_data = new float[num_ports];
 476         _shadow_data  = new float[num_ports];
 477         _defaults     = new float[num_ports];
 478         _ev_buffers   = new LV2_Evbuf*[num_ports];
 479         memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
 480
 481         const bool     latent        = lilv_plugin_has_latency(plugin);
 482         const uint32_t latency_index = (latent)
 483                 ? lilv_plugin_get_latency_port_index(plugin)
 484                 : 0;
 485
 486         // Build an array of pointers to special parameter buffers
 487         void*** params = new void**[num_ports];
 488         for (uint32_t i = 0; i < num_ports; ++i) {
 489                 params[i] = NULL;
 490         }
 491         _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
 492         _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
 493
 494         for (uint32_t i = 0; i < num_ports; ++i) {
 495                 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
 496                 const LilvNode* sym  = lilv_port_get_symbol(plugin, port);
 497
 498                 // Store index in map so we can look up index by symbol
 499                 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
 500
 501                 // Get range and default value if applicable
 502                 if (parameter_is_control(i)) {
 503                         LilvNode* def;
 504                         lilv_port_get_range(plugin, port, &def, NULL, NULL);
 505                         _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
 506                         if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
 507                                 _defaults[i] *= _session.frame_rate ();
 508                         }
 509                         lilv_node_free(def);
 510
 511                         lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
 512
 513                         if (latent && i == latency_index) {
 514                                 _latency_control_port  = &_control_data[i];
 515                                 *_latency_control_port = 0;
 516                         }
 517
 518                         if (parameter_is_input(i)) {
 519                                 _shadow_data[i] = default_value(i);
 520                                 if (params[i]) {
 521                                         *params[i] = (void*)&_shadow_data[i];
 522                                 }
 523                         }
 524                 } else {
 525                         _defaults[i] = 0.0f;
 526                 }
 527         }
 528
 529         delete[] params;
 530
 531         LilvUIs* uis = lilv_plugin_get_uis(plugin);
 532         if (lilv_uis_size(uis) > 0) {
 533 #ifdef HAVE_SUIL
 534                 // Look for embeddable UI
 535                 LILV_FOREACH(uis, u, uis) {
 536                         const LilvUI*   this_ui      = lilv_uis_get(uis, u);
 537                         const LilvNode* this_ui_type = NULL;
 538                         if (lilv_ui_is_supported(this_ui,
 539                                                  suil_ui_supported,
 540                                                  _world.ui_GtkUI,
 541                                                  &this_ui_type)) {
 542                                 // TODO: Multiple UI support
 543                                 _impl->ui      = this_ui;
 544                                 _impl->ui_type = this_ui_type;
 545                                 break;
 546                         }
 547                 }
 548 #else
 549                 // Look for Gtk native UI
 550                 LILV_FOREACH(uis, i, uis) {
 551                         const LilvUI* ui = lilv_uis_get(uis, i);
 552                         if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
 553                                 _impl->ui      = ui;
 554                                 _impl->ui_type = _world.ui_GtkUI;
 555                                 break;
 556                         }
 557                 }
 558 #endif
 559
 560                 // If Gtk UI is not available, try to find external UI
 561                 if (!_impl->ui) {
 562                         LILV_FOREACH(uis, i, uis) {
 563                                 const LilvUI* ui = lilv_uis_get(uis, i);
 564                                 if (lilv_ui_is_a(ui, _world.ui_external)) {
 565                                         _impl->ui      = ui;
 566                                         _impl->ui_type = _world.ui_external;
 567                                         break;
 568                                 }
 569                         }
 570                 }
 571         }
 572
 573         allocate_atom_event_buffers();
 574         latency_compute_run();
 575 }
 576
 577 LV2Plugin::~LV2Plugin ()
 578 {
 579         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
 580
 581         deactivate();
 582         cleanup();
 583
 584         lilv_instance_free(_impl->instance);
 585         lilv_node_free(_impl->name);
 586         lilv_node_free(_impl->author);
 587
 588         free(_features);
 589         free(_make_path_feature.data);
 590         free(_work_schedule_feature.data);
 591
 592         delete _to_ui;
 593         delete _from_ui;
 594         delete _worker;
 595
 596         if (_atom_ev_buffers) {
 597                 LV2_Evbuf**  b = _atom_ev_buffers;
 598                 while (*b) {
 599                         free(*b);
 600                         b++;
 601                 }
 602                 free(_atom_ev_buffers);
 603         }
 604
 605         delete [] _control_data;
 606         delete [] _shadow_data;
 607         delete [] _ev_buffers;
 608 }
 609
 610 bool
 611 LV2Plugin::is_external_ui() const
 612 {
 613         if (!_impl->ui) {
 614                 return false;
 615         }
 616         return lilv_ui_is_a(_impl->ui, _world.ui_external);
 617 }
 618
 619 bool
 620 LV2Plugin::ui_is_resizable () const
 621 {
 622         const LilvNode* s   = lilv_ui_get_uri(_impl->ui);
 623         LilvNode*       p   = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
 624         LilvNode*       fs  = lilv_new_uri(_world.world, LV2_UI__fixedSize);
 625         LilvNode*       nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
 626
 627         LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
 628         LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
 629
 630         lilv_nodes_free(nrs_matches);
 631         lilv_nodes_free(fs_matches);
 632         lilv_node_free(nrs);
 633         lilv_node_free(fs);
 634         lilv_node_free(p);
 635
 636         return !fs_matches && !nrs_matches;
 637 }
 638
 639 string
 640 LV2Plugin::unique_id() const
 641 {
 642         return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
 643 }
 644
 645 const char*
 646 LV2Plugin::uri() const
 647 {
 648         return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
 649 }
 650
 651 const char*
 652 LV2Plugin::label() const
 653 {
 654         return lilv_node_as_string(_impl->name);
 655 }
 656
 657 const char*
 658 LV2Plugin::name() const
 659 {
 660         return lilv_node_as_string(_impl->name);
 661 }
 662
 663 const char*
 664 LV2Plugin::maker() const
 665 {
 666         return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
 667 }
 668
 669 uint32_t
 670 LV2Plugin::num_ports() const
 671 {
 672         return lilv_plugin_get_num_ports(_impl->plugin);
 673 }
 674
 675 uint32_t
 676 LV2Plugin::parameter_count() const
 677 {
 678         return lilv_plugin_get_num_ports(_impl->plugin);
 679 }
 680
 681 float
 682 LV2Plugin::default_value(uint32_t port)
 683 {
 684         return _defaults[port];
 685 }
 686
 687 const char*
 688 LV2Plugin::port_symbol(uint32_t index) const
 689 {
 690         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
 691         if (!port) {
 692                 error << name() << ": Invalid port index " << index << endmsg;
 693         }
 694
 695         const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
 696         return lilv_node_as_string(sym);
 697 }
 698
 699 uint32_t
 700 LV2Plugin::port_index (const char* symbol) const
 701 {
 702         const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
 703         if (i != _port_indices.end()) {
 704                 return  i->second;
 705         } else {
 706                 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
 707                 return (uint32_t)-1;
 708         }
 709 }
 710
 711 void
 712 LV2Plugin::set_parameter(uint32_t which, float val)
 713 {
 714         DEBUG_TRACE(DEBUG::LV2, string_compose(
 715                             "%1 set parameter %2 to %3\n", name(), which, val));
 716
 717         if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
 718                 if (get_parameter (which) == val) {
 719                         return;
 720                 }
 721
 722                 _shadow_data[which] = val;
 723         } else {
 724                 warning << string_compose(
 725                     _("Illegal parameter number used with plugin \"%1\". "
 726                       "This is a bug in either %2 or the LV2 plugin <%3>"),
 727                     name(), PROGRAM_NAME, unique_id()) << endmsg;
 728         }
 729
 730         Plugin::set_parameter(which, val);
 731 }
 732
 733 float
 734 LV2Plugin::get_parameter(uint32_t which) const
 735 {
 736         if (parameter_is_input(which)) {
 737                 return (float)_shadow_data[which];
 738         } else {
 739                 return (float)_control_data[which];
 740         }
 741         return 0.0f;
 742 }
 743
 744 std::string
 745 LV2Plugin::get_docs() const
 746 {
 747         LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
 748         if (comments) {
 749                 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
 750                 lilv_nodes_free(comments);
 751                 return docs;
 752         }
 753
 754         return "";
 755 }
 756
 757 std::string
 758 LV2Plugin::get_parameter_docs(uint32_t which) const
 759 {
 760         LilvNodes* comments = lilv_port_get_value(
 761                 _impl->plugin,
 762                 lilv_plugin_get_port_by_index(_impl->plugin, which),
 763                 _world.rdfs_comment);
 764
 765         if (comments) {
 766                 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
 767                 lilv_nodes_free(comments);
 768                 return docs;
 769         }
 770
 771         return "";
 772 }
 773
 774 uint32_t
 775 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
 776 {
 777         ok = false;
 778         for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
 779                 if (parameter_is_control(x)) {
 780                         if (c++ == n) {
 781                                 ok = true;
 782                                 return x;
 783                         }
 784                 }
 785         }
 786
 787         return 0;
 788 }
 789
 790 const void*
 791 LV2Plugin::extension_data(const char* uri) const
 792 {
 793         return lilv_instance_get_extension_data(_impl->instance, uri);
 794 }
 795
 796 const void*
 797 LV2Plugin::c_plugin()
 798 {
 799         return _impl->plugin;
 800 }
 801
 802 const void*
 803 LV2Plugin::c_ui()
 804 {
 805         return (const void*)_impl->ui;
 806 }
 807
 808 const void*
 809 LV2Plugin::c_ui_type()
 810 {
 811         return (const void*)_impl->ui_type;
 812 }
 813
 814 /** Directory for all plugin state. */
 815 const std::string
 816 LV2Plugin::plugin_dir() const
 817 {
 818         return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
 819 }
 820
 821 /** Directory for files created by the plugin (except during save). */
 822 const std::string
 823 LV2Plugin::scratch_dir() const
 824 {
 825         return Glib::build_filename(plugin_dir(), "scratch");
 826 }
 827
 828 /** Directory for snapshots of files in the scratch directory. */
 829 const std::string
 830 LV2Plugin::file_dir() const
 831 {
 832         return Glib::build_filename(plugin_dir(), "files");
 833 }
 834
 835 /** Directory to save state snapshot version @c num into. */
 836 const std::string
 837 LV2Plugin::state_dir(unsigned num) const
 838 {
 839         return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
 840 }
 841
 842 /** Implementation of state:makePath for files created at instantiation time.
 843  * Note this is not used for files created at save time (Lilv deals with that).
 844  */
 845 char*
 846 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
 847                                const char*                path)
 848 {
 849         LV2Plugin* me = (LV2Plugin*)handle;
 850         if (me->_insert_id == PBD::ID("0")) {
 851                 warning << string_compose(
 852                         "File path \"%1\" requested but LV2 %2 has no insert ID",
 853                         path, me->name()) << endmsg;
 854                 return g_strdup(path);
 855         }
 856
 857         const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
 858         const std::string dirname  = Glib::path_get_dirname(abs_path);
 859         g_mkdir_with_parents(dirname.c_str(), 0744);
 860
 861         DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
 862                                                path, abs_path));
 863
 864         return g_strndup(abs_path.c_str(), abs_path.length());
 865 }
 866
 867 static void
 868 remove_directory(const std::string& path)
 869 {
 870         if (!Glib::file_test(path, Glib::FILE_TEST_IS_DIR)) {
 871                 warning << string_compose("\"%1\" is not a directory", path) << endmsg;
 872                 return;
 873         }
 874
 875         Glib::RefPtr<Gio::File>           dir = Gio::File::create_for_path(path);
 876         Glib::RefPtr<Gio::FileEnumerator> e   = dir->enumerate_children();
 877         Glib::RefPtr<Gio::FileInfo>       fi;
 878         while ((fi = e->next_file())) {
 879                 if (fi->get_type() == Gio::FILE_TYPE_DIRECTORY) {
 880                         remove_directory(fi->get_name());
 881                 } else {
 882                         dir->get_child(fi->get_name())->remove();
 883                 }
 884         }
 885         dir->remove();
 886 }
 887
 888 void
 889 LV2Plugin::add_state(XMLNode* root) const
 890 {
 891         assert(_insert_id != PBD::ID("0"));
 892
 893         XMLNode*    child;
 894         char        buf[16];
 895         LocaleGuard lg(X_("POSIX"));
 896
 897         for (uint32_t i = 0; i < parameter_count(); ++i) {
 898                 if (parameter_is_input(i) && parameter_is_control(i)) {
 899                         child = new XMLNode("Port");
 900                         child->add_property("symbol", port_symbol(i));
 901                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
 902                         child->add_property("value", string(buf));
 903                         root->add_child_nocopy(*child);
 904                 }
 905         }
 906
 907         if (_has_state_interface) {
 908                 // Provisionally increment state version and create directory
 909                 const std::string new_dir = state_dir(++_state_version);
 910                 g_mkdir_with_parents(new_dir.c_str(), 0744);
 911
 912                 LilvState* state = lilv_state_new_from_instance(
 913                         _impl->plugin,
 914                         _impl->instance,
 915                         _uri_map.urid_map(),
 916                         scratch_dir().c_str(),
 917                         file_dir().c_str(),
 918                         _session.externals_dir().c_str(),
 919                         new_dir.c_str(),
 920                         NULL,
 921                         const_cast<LV2Plugin*>(this),
 922                         0,
 923                         NULL);
 924
 925                 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
 926                         lilv_state_save(_world.world,
 927                                         _uri_map.urid_map(),
 928                                         _uri_map.urid_unmap(),
 929                                         state,
 930                                         NULL,
 931                                         new_dir.c_str(),
 932                                         "state.ttl");
 933
 934                         lilv_state_free(_impl->state);
 935                         _impl->state = state;
 936                 } else {
 937                         // State is identical, decrement version and nuke directory
 938                         lilv_state_free(state);
 939                         remove_directory(new_dir);
 940                         --_state_version;
 941                 }
 942
 943                 root->add_property("state-dir", string_compose("state%1", _state_version));
 944         }
 945 }
 946
 947 static inline const LilvNode*
 948 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
 949 {
 950         LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
 951         return vs ? lilv_nodes_get_first(vs) : NULL;
 952 }
 953
 954 void
 955 LV2Plugin::find_presets()
 956 {
 957         LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
 958         LilvNode* pset_Preset   = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
 959         LilvNode* rdfs_label    = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
 960
 961         LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
 962         LILV_FOREACH(nodes, i, presets) {
 963                 const LilvNode* preset = lilv_nodes_get(presets, i);
 964                 lilv_world_load_resource(_world.world, preset);
 965                 const LilvNode* name = get_value(_world.world, preset, rdfs_label);
 966                 if (name) {
 967                         _presets.insert(std::make_pair(lilv_node_as_string(preset),
 968                                                        Plugin::PresetRecord(
 969                                                                lilv_node_as_string(preset),
 970                                                                lilv_node_as_string(name))));
 971                 } else {
 972                         warning << string_compose(
 973                             _("Plugin \"%1\% preset \"%2%\" is missing a label\n"),
 974                             lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
 975                             lilv_node_as_string(preset)) << endmsg;
 976                 }
 977         }
 978         lilv_nodes_free(presets);
 979
 980         lilv_node_free(rdfs_label);
 981         lilv_node_free(pset_Preset);
 982         lilv_node_free(lv2_appliesTo);
 983 }
 984
 985 static void
 986 set_port_value(const char* port_symbol,
 987                void*       user_data,
 988                const void* value,
 989                uint32_t    /*size*/,
 990                uint32_t    type)
 991 {
 992         LV2Plugin* self = (LV2Plugin*)user_data;
 993         if (type != 0 && type != self->_uri_map.uri_to_id(LV2_ATOM__Float)) {
 994                 return;  // TODO: Support non-float ports
 995         }
 996
 997         const uint32_t port_index = self->port_index(port_symbol);
 998         if (port_index != (uint32_t)-1) {
 999                 self->set_parameter(port_index, *(const float*)value);
1000         }
1001 }
1002
1003 bool
1004 LV2Plugin::load_preset(PresetRecord r)
1005 {
1006         LilvWorld* world = _world.world;
1007         LilvNode*  pset  = lilv_new_uri(world, r.uri.c_str());
1008         LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1009
1010         if (state) {
1011                 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1012                 lilv_state_free(state);
1013         }
1014
1015         lilv_node_free(pset);
1016         return state;
1017 }
1018
1019 const void*
1020 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1021                                  void*       user_data,
1022                                  uint32_t*   size,
1023                                  uint32_t*   type)
1024 {
1025         LV2Plugin *plugin = (LV2Plugin *) user_data;
1026
1027         uint32_t index = plugin->port_index(port_symbol);
1028         if (index != (uint32_t) -1) {
1029                 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1030                         float *value;
1031                         *size = sizeof(float);
1032                         *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1033                         value = &plugin->_shadow_data[index];
1034
1035                         return value;
1036                 }
1037         }
1038
1039         *size = *type = 0;
1040         return NULL;
1041 }
1042
1043
1044 std::string
1045 LV2Plugin::do_save_preset(string name)
1046 {
1047         const string base_name = legalize_for_uri(name);
1048         const string file_name = base_name + ".ttl";
1049         const string bundle    = Glib::build_filename(
1050                 Glib::get_home_dir(),
1051                 Glib::build_filename(".lv2", base_name + ".lv2"));
1052
1053         LilvState* state = lilv_state_new_from_instance(
1054                 _impl->plugin,
1055                 _impl->instance,
1056                 _uri_map.urid_map(),
1057                 scratch_dir().c_str(),                   // file_dir
1058                 bundle.c_str(),                          // copy_dir
1059                 bundle.c_str(),                          // link_dir
1060                 bundle.c_str(),                          // save_dir
1061                 lv2plugin_get_port_value,                // get_value
1062                 (void*)this,                             // user_data
1063                 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE,  // flags
1064                 _features                                // features
1065         );
1066
1067         lilv_state_set_label(state, name.c_str());
1068         lilv_state_save(
1069                 _world.world,           // world
1070                 _uri_map.urid_map(),    // map
1071                 _uri_map.urid_unmap(),  // unmap
1072                 state,                  // state
1073                 NULL,                   // uri (NULL = use file URI)
1074                 bundle.c_str(),         // dir
1075                 file_name.c_str()       // filename
1076         );
1077
1078         lilv_state_free(state);
1079
1080         return Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1081 }
1082
1083 void
1084 LV2Plugin::do_remove_preset(string name)
1085 {
1086         string preset_file = Glib::build_filename(
1087                 Glib::get_home_dir(),
1088                 Glib::build_filename(
1089                         Glib::build_filename(".lv2", "presets"),
1090                         name + ".ttl"
1091                 )
1092         );
1093         unlink(preset_file.c_str());
1094 }
1095
1096 bool
1097 LV2Plugin::has_editor() const
1098 {
1099         return _impl->ui != NULL;
1100 }
1101
1102 bool
1103 LV2Plugin::has_message_output() const
1104 {
1105         for (uint32_t i = 0; i < num_ports(); ++i) {
1106                 if ((_port_flags[i] & PORT_SEQUENCE) &&
1107                     (_port_flags[i] & PORT_OUTPUT)) {
1108                         return true;
1109                 }
1110         }
1111         return false;
1112 }
1113
1114 bool
1115 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1116                     uint32_t             index,
1117                     uint32_t             protocol,
1118                     uint32_t             size,
1119                     const uint8_t*       body)
1120 {
1121         const uint32_t buf_size = sizeof(UIMessage) + size;
1122         uint8_t        buf[buf_size];
1123
1124         UIMessage* msg = (UIMessage*)buf;
1125         msg->index    = index;
1126         msg->protocol = protocol;
1127         msg->size     = size;
1128         memcpy(msg + 1, body, size);
1129
1130         return (dest->write(buf, buf_size) == buf_size);
1131 }
1132
1133 bool
1134 LV2Plugin::write_from_ui(uint32_t       index,
1135                          uint32_t       protocol,
1136                          uint32_t       size,
1137                          const uint8_t* body)
1138 {
1139         if (!_from_ui) {
1140                 _from_ui = new RingBuffer<uint8_t>(
1141                         _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS);
1142         }
1143
1144         if (!write_to(_from_ui, index, protocol, size, body)) {
1145                 error << "Error writing from UI to plugin" << endmsg;
1146                 return false;
1147         }
1148         return true;
1149 }
1150
1151 bool
1152 LV2Plugin::write_to_ui(uint32_t       index,
1153                        uint32_t       protocol,
1154                        uint32_t       size,
1155                        const uint8_t* body)
1156 {
1157         if (!write_to(_to_ui, index, protocol, size, body)) {
1158                 error << "Error writing from plugin to UI" << endmsg;
1159                 return false;
1160         }
1161         return true;
1162 }
1163
1164 void
1165 LV2Plugin::enable_ui_emmission()
1166 {
1167         if (!_to_ui) {
1168                 _to_ui = new RingBuffer<uint8_t>(
1169                         _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS);
1170         }
1171 }
1172
1173 void
1174 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1175 {
1176         if (!_to_ui) {
1177                 return;
1178         }
1179
1180         uint32_t read_space = _to_ui->read_space();
1181         while (read_space > sizeof(UIMessage)) {
1182                 UIMessage msg;
1183                 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1184                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1185                         break;
1186                 }
1187                 uint8_t body[msg.size];
1188                 if (_to_ui->read(body, msg.size) != msg.size) {
1189                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1190                         break;
1191                 }
1192
1193                 sink(controller, msg.index, msg.size, msg.protocol, body);
1194
1195                 read_space -= sizeof(msg) + msg.size;
1196         }
1197 }
1198
1199 int
1200 LV2Plugin::work(uint32_t size, const void* data)
1201 {
1202         return _impl->work_iface->work(
1203                 _impl->instance->lv2_handle, work_respond, this, size, data);
1204 }
1205
1206 int
1207 LV2Plugin::work_response(uint32_t size, const void* data)
1208 {
1209         return _impl->work_iface->work_response(
1210                 _impl->instance->lv2_handle, size, data);
1211 }
1212
1213 void
1214 LV2Plugin::set_insert_info(const PluginInsert* insert)
1215 {
1216         _insert_id = insert->id();
1217 }
1218
1219 int
1220 LV2Plugin::set_state(const XMLNode& node, int version)
1221 {
1222         XMLNodeList          nodes;
1223         const XMLProperty*   prop;
1224         XMLNodeConstIterator iter;
1225         XMLNode*             child;
1226         const char*          sym;
1227         const char*          value;
1228         uint32_t             port_id;
1229         LocaleGuard          lg(X_("POSIX"));
1230
1231         if (node.name() != state_node_name()) {
1232                 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1233                 return -1;
1234         }
1235
1236         if (version < 3000) {
1237                 nodes = node.children("port");
1238         } else {
1239                 nodes = node.children("Port");
1240         }
1241
1242         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1243
1244                 child = *iter;
1245
1246                 if ((prop = child->property("symbol")) != 0) {
1247                         sym = prop->value().c_str();
1248                 } else {
1249                         warning << _("LV2: port has no symbol, ignored") << endmsg;
1250                         continue;
1251                 }
1252
1253                 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1254
1255                 if (i != _port_indices.end()) {
1256                         port_id = i->second;
1257                 } else {
1258                         warning << _("LV2: port has unknown index, ignored") << endmsg;
1259                         continue;
1260                 }
1261
1262                 if ((prop = child->property("value")) != 0) {
1263                         value = prop->value().c_str();
1264                 } else {
1265                         warning << _("LV2: port has no value, ignored") << endmsg;
1266                         continue;
1267                 }
1268
1269                 set_parameter(port_id, atof(value));
1270         }
1271
1272         _state_version = 0;
1273         if ((prop = node.property("state-dir")) != 0) {
1274                 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1275                         error << string_compose(
1276                                 "LV2: failed to parse state version from \"%1\"",
1277                                 prop->value()) << endmsg;
1278                 }
1279
1280                 std::string state_file = Glib::build_filename(
1281                         plugin_dir(),
1282                         Glib::build_filename(prop->value(), "state.ttl"));
1283
1284                 LilvState* state = lilv_state_new_from_file(
1285                         _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1286
1287                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1288         }
1289
1290         latency_compute_run();
1291
1292         return Plugin::set_state(node, version);
1293 }
1294
1295 int
1296 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1297 {
1298         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1299
1300         LilvNode *def, *min, *max;
1301         lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1302
1303         desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1304         desc.toggled      = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1305         desc.logarithmic  = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1306         desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1307         desc.label        = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1308         desc.lower        = min ? lilv_node_as_float(min) : 0.0f;
1309         desc.upper        = max ? lilv_node_as_float(max) : 1.0f;
1310         if (desc.sr_dependent) {
1311                 desc.lower *= _session.frame_rate ();
1312                 desc.upper *= _session.frame_rate ();
1313         }
1314
1315         desc.min_unbound  = false; // TODO: LV2 extension required
1316         desc.max_unbound  = false; // TODO: LV2 extension required
1317
1318         if (desc.integer_step) {
1319                 desc.step      = 1.0;
1320                 desc.smallstep = 0.1;
1321                 desc.largestep = 10.0;
1322         } else {
1323                 const float delta = desc.upper - desc.lower;
1324                 desc.step      = delta / 1000.0f;
1325                 desc.smallstep = delta / 10000.0f;
1326                 desc.largestep = delta / 10.0f;
1327         }
1328
1329         desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1330
1331         lilv_node_free(def);
1332         lilv_node_free(min);
1333         lilv_node_free(max);
1334
1335         return 0;
1336 }
1337
1338 string
1339 LV2Plugin::describe_parameter(Evoral::Parameter which)
1340 {
1341         if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1342
1343                 if (lilv_port_has_property(_impl->plugin,
1344                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1345                         return X_("hidden");
1346                 }
1347
1348                 if (lilv_port_has_property(_impl->plugin,
1349                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1350                         return X_("hidden");
1351                 }
1352
1353                 if (lilv_port_has_property(_impl->plugin,
1354                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_sampleRate)) {
1355                         return X_("hidden");
1356                 }
1357
1358                 if (lilv_port_has_property(_impl->plugin,
1359                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1360                         return X_("latency");
1361                 }
1362
1363                 LilvNode* name = lilv_port_get_name(_impl->plugin,
1364                                                     lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1365                 string ret(lilv_node_as_string(name));
1366                 lilv_node_free(name);
1367                 return ret;
1368         } else {
1369                 return "??";
1370         }
1371 }
1372
1373 framecnt_t
1374 LV2Plugin::signal_latency() const
1375 {
1376         if (_latency_control_port) {
1377                 return (framecnt_t)floor(*_latency_control_port);
1378         } else {
1379                 return 0;
1380         }
1381 }
1382
1383 set<Evoral::Parameter>
1384 LV2Plugin::automatable() const
1385 {
1386         set<Evoral::Parameter> ret;
1387
1388         for (uint32_t i = 0; i < parameter_count(); ++i) {
1389                 if (parameter_is_input(i) && parameter_is_control(i)) {
1390                         ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1391                 }
1392         }
1393
1394         return ret;
1395 }
1396
1397 void
1398 LV2Plugin::activate()
1399 {
1400         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1401
1402         if (!_was_activated) {
1403                 lilv_instance_activate(_impl->instance);
1404                 _was_activated = true;
1405         }
1406 }
1407
1408 void
1409 LV2Plugin::deactivate()
1410 {
1411         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1412
1413         if (_was_activated) {
1414                 lilv_instance_deactivate(_impl->instance);
1415                 _was_activated = false;
1416         }
1417 }
1418
1419 void
1420 LV2Plugin::cleanup()
1421 {
1422         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1423
1424         activate();
1425         deactivate();
1426         lilv_instance_free(_impl->instance);
1427         _impl->instance = NULL;
1428 }
1429
1430 void
1431 LV2Plugin::allocate_atom_event_buffers()
1432 {
1433         /* reserve local scratch buffers for ATOM event-queues */
1434         const LilvPlugin* p = _impl->plugin;
1435
1436         /* count non-MIDI atom event-ports
1437          * TODO: nicely ask drobilla to make a lilv_ call for that
1438          */
1439         int count_atom_out = 0;
1440         int count_atom_in = 0;
1441         int minimumSize = 32768; // TODO use a per-port minimum-size
1442         for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1443                 const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
1444                 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1445                         LilvNodes* buffer_types = lilv_port_get_value(
1446                                 p, port, _world.atom_bufferType);
1447                         LilvNodes* atom_supports = lilv_port_get_value(
1448                                 p, port, _world.atom_supports);
1449
1450                         if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1451                                         || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1452                                 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1453                                         count_atom_in++;
1454                                 }
1455                                 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1456                                         count_atom_out++;
1457                                 }
1458                                 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1459                                 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1460                                 if (min_size && lilv_node_is_int(min_size)) {
1461                                         minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1462                                 }
1463                                 lilv_nodes_free(min_size_v);
1464                         }
1465                         lilv_nodes_free(buffer_types);
1466                         lilv_nodes_free(atom_supports);
1467                 }
1468         }
1469
1470         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1471                                 name(), count_atom_in, count_atom_out));
1472
1473         const int total_atom_buffers = (count_atom_in + count_atom_out);
1474         if (_atom_ev_buffers || total_atom_buffers == 0) {
1475                 return;
1476         }
1477
1478         DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers\n", total_atom_buffers));
1479         _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1480         for (int i = 0; i < total_atom_buffers; ++i ) {
1481                 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1482                                 LV2Plugin::urids.atom_Chunk, LV2Plugin::urids.atom_Sequence);
1483         }
1484         _atom_ev_buffers[total_atom_buffers] = 0;
1485         return;
1486 }
1487
1488 /** Write an ardour position/time/tempo/meter as an LV2 event.
1489  * @return true on success.
1490  */
1491 static bool
1492 write_position(LV2_Atom_Forge*     forge,
1493                LV2_Evbuf*          buf,
1494                const TempoMetric&  t,
1495                Timecode::BBT_Time& bbt,
1496                double              speed,
1497                framepos_t          position,
1498                framecnt_t          offset)
1499 {
1500         uint8_t pos_buf[256];
1501         lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1502         LV2_Atom_Forge_Frame frame;
1503         lv2_atom_forge_blank(forge, &frame, 1, LV2Plugin::urids.time_Position);
1504         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_frame, 0);
1505         lv2_atom_forge_long(forge, position);
1506         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_speed, 0);
1507         lv2_atom_forge_float(forge, speed);
1508         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_barBeat, 0);
1509         lv2_atom_forge_float(forge, bbt.beats - 1 +
1510                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1511         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_bar, 0);
1512         lv2_atom_forge_long(forge, bbt.bars - 1);
1513         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatUnit, 0);
1514         lv2_atom_forge_int(forge, t.meter().note_divisor());
1515         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatsPerBar, 0);
1516         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1517         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatsPerMinute, 0);
1518         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1519
1520         LV2_Evbuf_Iterator    end  = lv2_evbuf_end(buf);
1521         const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1522         return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1523                                (const uint8_t*)(atom + 1));
1524 }
1525
1526 int
1527 LV2Plugin::connect_and_run(BufferSet& bufs,
1528         ChanMapping in_map, ChanMapping out_map,
1529         pframes_t nframes, framecnt_t offset)
1530 {
1531         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1532         Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1533
1534         cycles_t then = get_cycles();
1535
1536         TempoMap&               tmap     = _session.tempo_map();
1537         Metrics::const_iterator metric_i = tmap.metrics_end();
1538         TempoMetric             tmetric  = tmap.metric_at(_session.transport_frame(), &metric_i);
1539
1540         if (_freewheel_control_port) {
1541                 *_freewheel_control_port = _session.engine().freewheeling();
1542         }
1543
1544         if (_bpm_control_port) {
1545                 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1546         }
1547
1548         ChanCount bufs_count;
1549         bufs_count.set(DataType::AUDIO, 1);
1550         bufs_count.set(DataType::MIDI, 1);
1551         BufferSet& silent_bufs  = _session.get_silent_buffers(bufs_count);
1552         BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1553         uint32_t const num_ports = parameter_count();
1554         uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1555
1556         uint32_t audio_in_index  = 0;
1557         uint32_t audio_out_index = 0;
1558         uint32_t midi_in_index   = 0;
1559         uint32_t midi_out_index  = 0;
1560         uint32_t atom_port_index = 0;
1561         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1562                 void*     buf   = NULL;
1563                 uint32_t  index = nil_index;
1564                 PortFlags flags = _port_flags[port_index];
1565                 bool      valid = false;
1566                 if (flags & PORT_AUDIO) {
1567                         if (flags & PORT_INPUT) {
1568                                 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1569                                 buf = (valid)
1570                                         ? bufs.get_audio(index).data(offset)
1571                                         : silent_bufs.get_audio(0).data(offset);
1572                         } else {
1573                                 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1574                                 buf = (valid)
1575                                         ? bufs.get_audio(index).data(offset)
1576                                         : scratch_bufs.get_audio(0).data(offset);
1577                         }
1578                 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1579                         /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1580                            be necessary, but the mapping is illegal in some cases.  Ideally
1581                            that should be fixed, but this is easier...
1582                         */
1583                         if (flags & PORT_MIDI) {
1584                                 if (flags & PORT_INPUT) {
1585                                         index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1586                                 } else {
1587                                         index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1588                                 }
1589                                 if (valid && bufs.count().n_midi() > index) {
1590                                         /* Note, ensure_lv2_bufsize() is not RT safe!
1591                                          * However free()/alloc() is only called if a
1592                                          * plugin requires a rsz:minimumSize buffersize
1593                                          * and the existing buffer if smaller.
1594                                          */
1595                                         bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1596                                         _ev_buffers[port_index] = bufs.get_lv2_midi(
1597                                                 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1598                                 }
1599                         } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1600                                 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1601                                 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1602                                 valid                   = true;
1603                         }
1604
1605                         if (valid && (flags & PORT_INPUT)) {
1606                                 Timecode::BBT_Time bbt;
1607                                 if ((flags & PORT_POSITION)) {
1608                                         if (_session.transport_frame() != _next_cycle_start ||
1609                                             _session.transport_speed() != _next_cycle_speed) {
1610                                                 // Transport has changed, write position at cycle start
1611                                                 tmap.bbt_time(_session.transport_frame(), bbt);
1612                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1613                                                                tmetric, bbt, _session.transport_speed(),
1614                                                                _session.transport_frame(), 0);
1615                                         }
1616                                 }
1617
1618                                 // Get MIDI iterator range (empty range if no MIDI)
1619                                 MidiBuffer::iterator m = (index != nil_index)
1620                                         ? bufs.get_midi(index).begin()
1621                                         : silent_bufs.get_midi(0).end();
1622                                 MidiBuffer::iterator m_end = (index != nil_index)
1623                                         ? bufs.get_midi(index).end()
1624                                         : m;
1625
1626                                 // Now merge MIDI and any transport events into the buffer
1627                                 const uint32_t     type = LV2Plugin::urids.midi_MidiEvent;
1628                                 const framepos_t   tend = _session.transport_frame() + nframes;
1629                                 ++metric_i;
1630                                 while (m != m_end || (metric_i != tmap.metrics_end() &&
1631                                                       (*metric_i)->frame() < tend)) {
1632                                         MetricSection* metric = (metric_i != tmap.metrics_end())
1633                                                 ? *metric_i : NULL;
1634                                         if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1635                                                 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1636                                                 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1637                                                 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1638                                                 ++m;
1639                                         } else {
1640                                                 tmetric.set_metric(metric);
1641                                                 bbt = metric->start();
1642                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1643                                                                tmetric, bbt, _session.transport_speed(),
1644                                                                metric->frame(),
1645                                                                metric->frame() - _session.transport_frame());
1646                                                 ++metric_i;
1647                                         }
1648                                 }
1649                         } else if (!valid) {
1650                                 // Nothing we understand or care about, connect to scratch
1651                                 _ev_buffers[port_index] = silent_bufs.get_lv2_midi(
1652                                         (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
1653                         }
1654                         buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
1655                 } else {
1656                         continue;  // Control port, leave buffer alone
1657                 }
1658                 lilv_instance_connect_port(_impl->instance, port_index, buf);
1659         }
1660
1661         // Read messages from UI and push into appropriate buffers
1662         if (_from_ui) {
1663                 uint32_t read_space = _from_ui->read_space();
1664                 while (read_space > sizeof(UIMessage)) {
1665                         UIMessage msg;
1666                         if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1667                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1668                                 break;
1669                         }
1670                         uint8_t body[msg.size];
1671                         if (_from_ui->read(body, msg.size) != msg.size) {
1672                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1673                                 break;
1674                         }
1675                         if (msg.protocol == urids.atom_eventTransfer) {
1676                                 LV2_Evbuf*            buf  = _ev_buffers[msg.index];
1677                                 LV2_Evbuf_Iterator    i    = lv2_evbuf_end(buf);
1678                                 const LV2_Atom* const atom = (const LV2_Atom*)body;
1679                                 if (!lv2_evbuf_write(&i, nframes, 0, atom->type, atom->size,
1680                                                 (const uint8_t*)(atom + 1))) {
1681                                         error << "Failed to write data to LV2 event buffer\n";
1682                                 }
1683                         } else {
1684                                 error << "Received unknown message type from UI" << endmsg;
1685                         }
1686                         read_space -= sizeof(UIMessage) + msg.size;
1687                 }
1688         }
1689
1690         run(nframes);
1691
1692         midi_out_index = 0;
1693         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1694                 PortFlags flags = _port_flags[port_index];
1695                 bool      valid = false;
1696
1697                 /* TODO ask drobilla about comment
1698                  * "Make Ardour event buffers generic so plugins can communicate"
1699                  * in libs/ardour/buffer_set.cc:310
1700                  *
1701                  * ideally the user could choose which of the following two modes
1702                  * to use (e.g. instrument/effect chains  MIDI OUT vs MIDI TRHU).
1703                  *
1704                  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
1705                  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
1706                  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
1707                  *                            for quite a while at least ;)
1708                  */
1709                 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
1710                 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
1711                         const uint32_t buf_index = out_map.get(
1712                                 DataType::MIDI, midi_out_index++, &valid);
1713                         if (valid) {
1714                                 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
1715                         }
1716                 }
1717                 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
1718                 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
1719                         const uint32_t buf_index = out_map.get(
1720                                 DataType::MIDI, midi_out_index++, &valid);
1721                         if (valid) {
1722                                 bufs.flush_lv2_midi(true, buf_index);
1723                         }
1724                 }
1725
1726                 // Write messages to UI
1727                 if (_to_ui && (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
1728                         LV2_Evbuf* buf = _ev_buffers[port_index];
1729                         for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
1730                              lv2_evbuf_is_valid(i);
1731                              i = lv2_evbuf_next(i)) {
1732                                 uint32_t frames, subframes, type, size;
1733                                 uint8_t* data;
1734                                 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
1735                                 write_to_ui(port_index, urids.atom_eventTransfer,
1736                                             size + sizeof(LV2_Atom),
1737                                             data - sizeof(LV2_Atom));
1738                         }
1739                 }
1740         }
1741
1742         cycles_t now = get_cycles();
1743         set_cycles((uint32_t)(now - then));
1744
1745         // Update expected transport information for next cycle so we can detect changes
1746         _next_cycle_speed = _session.transport_speed();
1747         _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
1748
1749         return 0;
1750 }
1751
1752 bool
1753 LV2Plugin::parameter_is_control(uint32_t param) const
1754 {
1755         assert(param < _port_flags.size());
1756         return _port_flags[param] & PORT_CONTROL;
1757 }
1758
1759 bool
1760 LV2Plugin::parameter_is_audio(uint32_t param) const
1761 {
1762         assert(param < _port_flags.size());
1763         return _port_flags[param] & PORT_AUDIO;
1764 }
1765
1766 bool
1767 LV2Plugin::parameter_is_event(uint32_t param) const
1768 {
1769         assert(param < _port_flags.size());
1770         return _port_flags[param] & PORT_EVENT;
1771 }
1772
1773 bool
1774 LV2Plugin::parameter_is_output(uint32_t param) const
1775 {
1776         assert(param < _port_flags.size());
1777         return _port_flags[param] & PORT_OUTPUT;
1778 }
1779
1780 bool
1781 LV2Plugin::parameter_is_input(uint32_t param) const
1782 {
1783         assert(param < _port_flags.size());
1784         return _port_flags[param] & PORT_INPUT;
1785 }
1786
1787 void
1788 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
1789 {
1790         if (buf && len) {
1791                 if (param < parameter_count()) {
1792                         snprintf(buf, len, "%.3f", get_parameter(param));
1793                 } else {
1794                         strcat(buf, "0");
1795                 }
1796         }
1797 }
1798
1799 boost::shared_ptr<Plugin::ScalePoints>
1800 LV2Plugin::get_scale_points(uint32_t port_index) const
1801 {
1802         const LilvPort*  port   = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
1803         LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
1804
1805         boost::shared_ptr<Plugin::ScalePoints> ret;
1806         if (!points) {
1807                 return ret;
1808         }
1809
1810         ret = boost::shared_ptr<Plugin::ScalePoints>(new ScalePoints());
1811
1812         LILV_FOREACH(scale_points, i, points) {
1813                 const LilvScalePoint* p     = lilv_scale_points_get(points, i);
1814                 const LilvNode*       label = lilv_scale_point_get_label(p);
1815                 const LilvNode*       value = lilv_scale_point_get_value(p);
1816                 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
1817                         ret->insert(make_pair(lilv_node_as_string(label),
1818                                               lilv_node_as_float(value)));
1819                 }
1820         }
1821
1822         lilv_scale_points_free(points);
1823         return ret;
1824 }
1825
1826 void
1827 LV2Plugin::run(pframes_t nframes)
1828 {
1829         uint32_t const N = parameter_count();
1830         for (uint32_t i = 0; i < N; ++i) {
1831                 if (parameter_is_control(i) && parameter_is_input(i)) {
1832                         _control_data[i] = _shadow_data[i];
1833                 }
1834         }
1835
1836         lilv_instance_run(_impl->instance, nframes);
1837
1838         if (_impl->work_iface) {
1839                 _worker->emit_responses();
1840                 if (_impl->work_iface->end_run) {
1841                         _impl->work_iface->end_run(_impl->instance->lv2_handle);
1842                 }
1843         }
1844 }
1845
1846 void
1847 LV2Plugin::latency_compute_run()
1848 {
1849         if (!_latency_control_port) {
1850                 return;
1851         }
1852
1853         // Run the plugin so that it can set its latency parameter
1854
1855         activate();
1856
1857         uint32_t port_index = 0;
1858         uint32_t in_index   = 0;
1859         uint32_t out_index  = 0;
1860
1861         const framecnt_t bufsize = 1024;
1862         float            buffer[bufsize];
1863
1864         memset(buffer, 0, sizeof(float) * bufsize);
1865
1866         // FIXME: Ensure plugins can handle in-place processing
1867
1868         port_index = 0;
1869
1870         while (port_index < parameter_count()) {
1871                 if (parameter_is_audio(port_index)) {
1872                         if (parameter_is_input(port_index)) {
1873                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
1874                                 in_index++;
1875                         } else if (parameter_is_output(port_index)) {
1876                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
1877                                 out_index++;
1878                         }
1879                 }
1880                 port_index++;
1881         }
1882
1883         run(bufsize);
1884         deactivate();
1885 }
1886
1887 const LilvPort*
1888 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
1889 {
1890         const LilvPort* port = NULL;
1891         LilvNode* designation = lilv_new_uri(_world.world, uri);
1892         port = lilv_plugin_get_port_by_designation(
1893                 plugin, _world.lv2_InputPort, designation);
1894         lilv_node_free(designation);
1895         if (port) {
1896                 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
1897         }
1898         return port;
1899 }
1900
1901 static bool lv2_filter (const string& str, void *arg)
1902 {
1903         /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
1904
1905         return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
1906 }
1907
1908
1909 LV2World::LV2World()
1910         : world(lilv_world_new())
1911         , _bundle_checked(false)
1912 {
1913         lilv_world_load_all(world);
1914
1915         atom_AtomPort      = lilv_new_uri(world, LV2_ATOM__AtomPort);
1916         atom_Chunk         = lilv_new_uri(world, LV2_ATOM__Chunk);
1917         atom_Sequence      = lilv_new_uri(world, LV2_ATOM__Sequence);
1918         atom_bufferType    = lilv_new_uri(world, LV2_ATOM__bufferType);
1919         atom_supports      = lilv_new_uri(world, LV2_ATOM__supports);
1920         atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
1921         ev_EventPort       = lilv_new_uri(world, LILV_URI_EVENT_PORT);
1922         ext_logarithmic    = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
1923         ext_notOnGUI       = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
1924         lv2_AudioPort      = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
1925         lv2_ControlPort    = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
1926         lv2_InputPort      = lilv_new_uri(world, LILV_URI_INPUT_PORT);
1927         lv2_OutputPort     = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
1928         lv2_inPlaceBroken  = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
1929         lv2_integer        = lilv_new_uri(world, LV2_CORE__integer);
1930         lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
1931         lv2_sampleRate     = lilv_new_uri(world, LV2_CORE__sampleRate);
1932         lv2_toggled        = lilv_new_uri(world, LV2_CORE__toggled);
1933         lv2_enumeration    = lilv_new_uri(world, LV2_CORE__enumeration);
1934         lv2_freewheeling   = lilv_new_uri(world, LV2_CORE__freeWheeling);
1935         midi_MidiEvent     = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
1936         rdfs_comment       = lilv_new_uri(world, LILV_NS_RDFS "comment");
1937         rsz_minimumSize    = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
1938         time_Position      = lilv_new_uri(world, LV2_TIME__Position);
1939         ui_GtkUI           = lilv_new_uri(world, LV2_UI__GtkUI);
1940         ui_external        = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
1941 }
1942
1943 LV2World::~LV2World()
1944 {
1945         lilv_node_free(ui_external);
1946         lilv_node_free(ui_GtkUI);
1947         lilv_node_free(time_Position);
1948         lilv_node_free(rsz_minimumSize);
1949         lilv_node_free(rdfs_comment);
1950         lilv_node_free(midi_MidiEvent);
1951         lilv_node_free(lv2_enumeration);
1952         lilv_node_free(lv2_freewheeling);
1953         lilv_node_free(lv2_toggled);
1954         lilv_node_free(lv2_sampleRate);
1955         lilv_node_free(lv2_reportsLatency);
1956         lilv_node_free(lv2_integer);
1957         lilv_node_free(lv2_inPlaceBroken);
1958         lilv_node_free(lv2_OutputPort);
1959         lilv_node_free(lv2_InputPort);
1960         lilv_node_free(lv2_ControlPort);
1961         lilv_node_free(lv2_AudioPort);
1962         lilv_node_free(ext_notOnGUI);
1963         lilv_node_free(ext_logarithmic);
1964         lilv_node_free(ev_EventPort);
1965         lilv_node_free(atom_supports);
1966         lilv_node_free(atom_eventTransfer);
1967         lilv_node_free(atom_bufferType);
1968         lilv_node_free(atom_Sequence);
1969         lilv_node_free(atom_Chunk);
1970         lilv_node_free(atom_AtomPort);
1971 }
1972
1973 void
1974 LV2World::load_bundled_plugins()
1975 {
1976         if (!_bundle_checked) {
1977                 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
1978                 PathScanner scanner;
1979                 vector<string *> *plugin_objects = scanner (ARDOUR::lv2_bundled_search_path().to_string(), lv2_filter, 0, true, true);
1980                 if (plugin_objects) {
1981                         for ( vector<string *>::iterator x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
1982 #ifdef WINDOWS
1983                                         string uri = "file:///" + **x + "/";
1984 #else
1985                                         string uri = "file://" + **x + "/";
1986 #endif
1987                                         LilvNode *node = lilv_new_uri(world, uri.c_str());
1988                                         lilv_world_load_bundle(world, node);
1989                                         lilv_node_free(node);
1990                                 }
1991                         }
1992                 delete (plugin_objects);
1993         }
1994 }
1995
1996 LV2PluginInfo::LV2PluginInfo (const void* c_plugin)
1997         : _c_plugin(c_plugin)
1998 {
1999         type = ARDOUR::LV2;
2000 }
2001
2002 LV2PluginInfo::~LV2PluginInfo()
2003 {}
2004
2005 PluginPtr
2006 LV2PluginInfo::load(Session& session)
2007 {
2008         try {
2009                 PluginPtr plugin;
2010
2011                 plugin.reset(new LV2Plugin(session.engine(), session,
2012                                            (const LilvPlugin*)_c_plugin,
2013                                            session.frame_rate()));
2014
2015                 plugin->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
2016                 return plugin;
2017         } catch (failed_constructor& err) {
2018                 return PluginPtr((Plugin*)0);
2019         }
2020
2021         return PluginPtr();
2022 }
2023
2024 PluginInfoList*
2025 LV2PluginInfo::discover()
2026 {
2027         _world.load_bundled_plugins();
2028
2029         PluginInfoList*    plugs   = new PluginInfoList;
2030         const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2031
2032         info << "LV2: Discovering " << lilv_plugins_size(plugins) << " plugins" << endmsg;
2033
2034         LILV_FOREACH(plugins, i, plugins) {
2035                 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2036                 LV2PluginInfoPtr  info(new LV2PluginInfo((const void*)p));
2037
2038                 LilvNode* name = lilv_plugin_get_name(p);
2039                 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2040                         warning << "Ignoring invalid LV2 plugin "
2041                                 << lilv_node_as_string(lilv_plugin_get_uri(p))
2042                                 << endmsg;
2043                         continue;
2044                 }
2045
2046                 info->type = LV2;
2047
2048                 info->name = string(lilv_node_as_string(name));
2049                 lilv_node_free(name);
2050
2051                 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2052                 const LilvNode*        label  = lilv_plugin_class_get_label(pclass);
2053                 info->category = lilv_node_as_string(label);
2054
2055                 LilvNode* author_name = lilv_plugin_get_author_name(p);
2056                 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2057                 lilv_node_free(author_name);
2058
2059                 info->path = "/NOPATH"; // Meaningless for LV2
2060
2061                 /* count atom-event-ports that feature
2062                  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2063                  *
2064                  * TODO: nicely ask drobilla to make a lilv_ call for that
2065                  */
2066                 int count_midi_out = 0;
2067                 int count_midi_in = 0;
2068                 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2069                         const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
2070                         if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2071                                 LilvNodes* buffer_types = lilv_port_get_value(
2072                                         p, port, _world.atom_bufferType);
2073                                 LilvNodes* atom_supports = lilv_port_get_value(
2074                                         p, port, _world.atom_supports);
2075
2076                                 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)
2077                                                 && lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
2078                                         if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2079                                                 count_midi_in++;
2080                                         }
2081                                         if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2082                                                 count_midi_out++;
2083                                         }
2084                                 }
2085                                 lilv_nodes_free(buffer_types);
2086                                 lilv_nodes_free(atom_supports);
2087                         }
2088                 }
2089
2090                 info->n_inputs.set_audio(
2091                         lilv_plugin_get_num_ports_of_class(
2092                                 p, _world.lv2_InputPort, _world.lv2_AudioPort, NULL));
2093                 info->n_inputs.set_midi(
2094                         lilv_plugin_get_num_ports_of_class(
2095                                 p, _world.lv2_InputPort, _world.ev_EventPort, NULL)
2096                         + count_midi_in);
2097
2098                 info->n_outputs.set_audio(
2099                         lilv_plugin_get_num_ports_of_class(
2100                                 p, _world.lv2_OutputPort, _world.lv2_AudioPort, NULL));
2101                 info->n_outputs.set_midi(
2102                         lilv_plugin_get_num_ports_of_class(
2103                                 p, _world.lv2_OutputPort, _world.ev_EventPort, NULL)
2104                         + count_midi_out);
2105
2106                 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2107                 info->index     = 0; // Meaningless for LV2
2108
2109                 plugs->push_back(info);
2110         }
2111
2112         return plugs;
2113 }