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 #ifndef NO_PLUGIN_STATE
1237
1238         if (version < 3000) {
1239                 nodes = node.children("port");
1240         } else {
1241                 nodes = node.children("Port");
1242         }
1243
1244         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1245
1246                 child = *iter;
1247
1248                 if ((prop = child->property("symbol")) != 0) {
1249                         sym = prop->value().c_str();
1250                 } else {
1251                         warning << _("LV2: port has no symbol, ignored") << endmsg;
1252                         continue;
1253                 }
1254
1255                 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1256
1257                 if (i != _port_indices.end()) {
1258                         port_id = i->second;
1259                 } else {
1260                         warning << _("LV2: port has unknown index, ignored") << endmsg;
1261                         continue;
1262                 }
1263
1264                 if ((prop = child->property("value")) != 0) {
1265                         value = prop->value().c_str();
1266                 } else {
1267                         warning << _("LV2: port has no value, ignored") << endmsg;
1268                         continue;
1269                 }
1270
1271                 set_parameter(port_id, atof(value));
1272         }
1273
1274         _state_version = 0;
1275         if ((prop = node.property("state-dir")) != 0) {
1276                 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1277                         error << string_compose(
1278                                 "LV2: failed to parse state version from \"%1\"",
1279                                 prop->value()) << endmsg;
1280                 }
1281
1282                 std::string state_file = Glib::build_filename(
1283                         plugin_dir(),
1284                         Glib::build_filename(prop->value(), "state.ttl"));
1285
1286                 LilvState* state = lilv_state_new_from_file(
1287                         _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1288
1289                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1290         }
1291
1292         latency_compute_run();
1293 #endif
1294
1295         return Plugin::set_state(node, version);
1296 }
1297
1298 int
1299 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1300 {
1301         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1302
1303         LilvNode *def, *min, *max;
1304         lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1305
1306         desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1307         desc.toggled      = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1308         desc.logarithmic  = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1309         desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1310         desc.label        = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1311         desc.lower        = min ? lilv_node_as_float(min) : 0.0f;
1312         desc.upper        = max ? lilv_node_as_float(max) : 1.0f;
1313         if (desc.sr_dependent) {
1314                 desc.lower *= _session.frame_rate ();
1315                 desc.upper *= _session.frame_rate ();
1316         }
1317
1318         desc.min_unbound  = false; // TODO: LV2 extension required
1319         desc.max_unbound  = false; // TODO: LV2 extension required
1320
1321         if (desc.integer_step) {
1322                 desc.step      = 1.0;
1323                 desc.smallstep = 0.1;
1324                 desc.largestep = 10.0;
1325         } else {
1326                 const float delta = desc.upper - desc.lower;
1327                 desc.step      = delta / 1000.0f;
1328                 desc.smallstep = delta / 10000.0f;
1329                 desc.largestep = delta / 10.0f;
1330         }
1331
1332         desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1333
1334         lilv_node_free(def);
1335         lilv_node_free(min);
1336         lilv_node_free(max);
1337
1338         return 0;
1339 }
1340
1341 string
1342 LV2Plugin::describe_parameter(Evoral::Parameter which)
1343 {
1344         if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1345
1346                 if (lilv_port_has_property(_impl->plugin,
1347                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1348                         return X_("hidden");
1349                 }
1350
1351                 if (lilv_port_has_property(_impl->plugin,
1352                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1353                         return X_("hidden");
1354                 }
1355
1356                 if (lilv_port_has_property(_impl->plugin,
1357                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_sampleRate)) {
1358                         return X_("hidden");
1359                 }
1360
1361                 if (lilv_port_has_property(_impl->plugin,
1362                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1363                         return X_("latency");
1364                 }
1365
1366                 LilvNode* name = lilv_port_get_name(_impl->plugin,
1367                                                     lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1368                 string ret(lilv_node_as_string(name));
1369                 lilv_node_free(name);
1370                 return ret;
1371         } else {
1372                 return "??";
1373         }
1374 }
1375
1376 framecnt_t
1377 LV2Plugin::signal_latency() const
1378 {
1379         if (_latency_control_port) {
1380                 return (framecnt_t)floor(*_latency_control_port);
1381         } else {
1382                 return 0;
1383         }
1384 }
1385
1386 set<Evoral::Parameter>
1387 LV2Plugin::automatable() const
1388 {
1389         set<Evoral::Parameter> ret;
1390
1391         for (uint32_t i = 0; i < parameter_count(); ++i) {
1392                 if (parameter_is_input(i) && parameter_is_control(i)) {
1393                         ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1394                 }
1395         }
1396
1397         return ret;
1398 }
1399
1400 void
1401 LV2Plugin::activate()
1402 {
1403         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1404
1405         if (!_was_activated) {
1406                 lilv_instance_activate(_impl->instance);
1407                 _was_activated = true;
1408         }
1409 }
1410
1411 void
1412 LV2Plugin::deactivate()
1413 {
1414         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1415
1416         if (_was_activated) {
1417                 lilv_instance_deactivate(_impl->instance);
1418                 _was_activated = false;
1419         }
1420 }
1421
1422 void
1423 LV2Plugin::cleanup()
1424 {
1425         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1426
1427         activate();
1428         deactivate();
1429         lilv_instance_free(_impl->instance);
1430         _impl->instance = NULL;
1431 }
1432
1433 void
1434 LV2Plugin::allocate_atom_event_buffers()
1435 {
1436         /* reserve local scratch buffers for ATOM event-queues */
1437         const LilvPlugin* p = _impl->plugin;
1438
1439         /* count non-MIDI atom event-ports
1440          * TODO: nicely ask drobilla to make a lilv_ call for that
1441          */
1442         int count_atom_out = 0;
1443         int count_atom_in = 0;
1444         int minimumSize = 32768; // TODO use a per-port minimum-size
1445         for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1446                 const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
1447                 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1448                         LilvNodes* buffer_types = lilv_port_get_value(
1449                                 p, port, _world.atom_bufferType);
1450                         LilvNodes* atom_supports = lilv_port_get_value(
1451                                 p, port, _world.atom_supports);
1452
1453                         if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1454                                         || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1455                                 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1456                                         count_atom_in++;
1457                                 }
1458                                 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1459                                         count_atom_out++;
1460                                 }
1461                                 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1462                                 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1463                                 if (min_size && lilv_node_is_int(min_size)) {
1464                                         minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1465                                 }
1466                                 lilv_nodes_free(min_size_v);
1467                         }
1468                         lilv_nodes_free(buffer_types);
1469                         lilv_nodes_free(atom_supports);
1470                 }
1471         }
1472
1473         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1474                                 name(), count_atom_in, count_atom_out));
1475
1476         const int total_atom_buffers = (count_atom_in + count_atom_out);
1477         if (_atom_ev_buffers || total_atom_buffers == 0) {
1478                 return;
1479         }
1480
1481         DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers\n", total_atom_buffers));
1482         _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1483         for (int i = 0; i < total_atom_buffers; ++i ) {
1484                 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1485                                 LV2Plugin::urids.atom_Chunk, LV2Plugin::urids.atom_Sequence);
1486         }
1487         _atom_ev_buffers[total_atom_buffers] = 0;
1488         return;
1489 }
1490
1491 /** Write an ardour position/time/tempo/meter as an LV2 event.
1492  * @return true on success.
1493  */
1494 static bool
1495 write_position(LV2_Atom_Forge*     forge,
1496                LV2_Evbuf*          buf,
1497                const TempoMetric&  t,
1498                Timecode::BBT_Time& bbt,
1499                double              speed,
1500                framepos_t          position,
1501                framecnt_t          offset)
1502 {
1503         uint8_t pos_buf[256];
1504         lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1505         LV2_Atom_Forge_Frame frame;
1506         lv2_atom_forge_blank(forge, &frame, 1, LV2Plugin::urids.time_Position);
1507         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_frame, 0);
1508         lv2_atom_forge_long(forge, position);
1509         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_speed, 0);
1510         lv2_atom_forge_float(forge, speed);
1511         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_barBeat, 0);
1512         lv2_atom_forge_float(forge, bbt.beats - 1 +
1513                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1514         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_bar, 0);
1515         lv2_atom_forge_long(forge, bbt.bars - 1);
1516         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatUnit, 0);
1517         lv2_atom_forge_int(forge, t.meter().note_divisor());
1518         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatsPerBar, 0);
1519         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1520         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatsPerMinute, 0);
1521         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1522
1523         LV2_Evbuf_Iterator    end  = lv2_evbuf_end(buf);
1524         const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1525         return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1526                                (const uint8_t*)(atom + 1));
1527 }
1528
1529 int
1530 LV2Plugin::connect_and_run(BufferSet& bufs,
1531         ChanMapping in_map, ChanMapping out_map,
1532         pframes_t nframes, framecnt_t offset)
1533 {
1534         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1535         Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1536
1537         cycles_t then = get_cycles();
1538
1539         TempoMap&               tmap     = _session.tempo_map();
1540         Metrics::const_iterator metric_i = tmap.metrics_end();
1541         TempoMetric             tmetric  = tmap.metric_at(_session.transport_frame(), &metric_i);
1542
1543         if (_freewheel_control_port) {
1544                 *_freewheel_control_port = _session.engine().freewheeling();
1545         }
1546
1547         if (_bpm_control_port) {
1548                 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1549         }
1550
1551         ChanCount bufs_count;
1552         bufs_count.set(DataType::AUDIO, 1);
1553         bufs_count.set(DataType::MIDI, 1);
1554         BufferSet& silent_bufs  = _session.get_silent_buffers(bufs_count);
1555         BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1556         uint32_t const num_ports = parameter_count();
1557         uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1558
1559         uint32_t audio_in_index  = 0;
1560         uint32_t audio_out_index = 0;
1561         uint32_t midi_in_index   = 0;
1562         uint32_t midi_out_index  = 0;
1563         uint32_t atom_port_index = 0;
1564         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1565                 void*     buf   = NULL;
1566                 uint32_t  index = nil_index;
1567                 PortFlags flags = _port_flags[port_index];
1568                 bool      valid = false;
1569                 if (flags & PORT_AUDIO) {
1570                         if (flags & PORT_INPUT) {
1571                                 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1572                                 buf = (valid)
1573                                         ? bufs.get_audio(index).data(offset)
1574                                         : silent_bufs.get_audio(0).data(offset);
1575                         } else {
1576                                 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1577                                 buf = (valid)
1578                                         ? bufs.get_audio(index).data(offset)
1579                                         : scratch_bufs.get_audio(0).data(offset);
1580                         }
1581                 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1582                         /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1583                            be necessary, but the mapping is illegal in some cases.  Ideally
1584                            that should be fixed, but this is easier...
1585                         */
1586                         if (flags & PORT_MIDI) {
1587                                 if (flags & PORT_INPUT) {
1588                                         index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1589                                 } else {
1590                                         index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1591                                 }
1592                                 if (valid && bufs.count().n_midi() > index) {
1593                                         /* Note, ensure_lv2_bufsize() is not RT safe!
1594                                          * However free()/alloc() is only called if a
1595                                          * plugin requires a rsz:minimumSize buffersize
1596                                          * and the existing buffer if smaller.
1597                                          */
1598                                         bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1599                                         _ev_buffers[port_index] = bufs.get_lv2_midi(
1600                                                 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1601                                 }
1602                         } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1603                                 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1604                                 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1605                                 valid                   = true;
1606                         }
1607
1608                         if (valid && (flags & PORT_INPUT)) {
1609                                 Timecode::BBT_Time bbt;
1610                                 if ((flags & PORT_POSITION)) {
1611                                         if (_session.transport_frame() != _next_cycle_start ||
1612                                             _session.transport_speed() != _next_cycle_speed) {
1613                                                 // Transport has changed, write position at cycle start
1614                                                 tmap.bbt_time(_session.transport_frame(), bbt);
1615                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1616                                                                tmetric, bbt, _session.transport_speed(),
1617                                                                _session.transport_frame(), 0);
1618                                         }
1619                                 }
1620
1621                                 // Get MIDI iterator range (empty range if no MIDI)
1622                                 MidiBuffer::iterator m = (index != nil_index)
1623                                         ? bufs.get_midi(index).begin()
1624                                         : silent_bufs.get_midi(0).end();
1625                                 MidiBuffer::iterator m_end = (index != nil_index)
1626                                         ? bufs.get_midi(index).end()
1627                                         : m;
1628
1629                                 // Now merge MIDI and any transport events into the buffer
1630                                 const uint32_t     type = LV2Plugin::urids.midi_MidiEvent;
1631                                 const framepos_t   tend = _session.transport_frame() + nframes;
1632                                 ++metric_i;
1633                                 while (m != m_end || (metric_i != tmap.metrics_end() &&
1634                                                       (*metric_i)->frame() < tend)) {
1635                                         MetricSection* metric = (metric_i != tmap.metrics_end())
1636                                                 ? *metric_i : NULL;
1637                                         if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1638                                                 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1639                                                 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1640                                                 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1641                                                 ++m;
1642                                         } else {
1643                                                 tmetric.set_metric(metric);
1644                                                 bbt = metric->start();
1645                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1646                                                                tmetric, bbt, _session.transport_speed(),
1647                                                                metric->frame(),
1648                                                                metric->frame() - _session.transport_frame());
1649                                                 ++metric_i;
1650                                         }
1651                                 }
1652                         } else if (!valid) {
1653                                 // Nothing we understand or care about, connect to scratch
1654                                 _ev_buffers[port_index] = silent_bufs.get_lv2_midi(
1655                                         (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
1656                         }
1657                         buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
1658                 } else {
1659                         continue;  // Control port, leave buffer alone
1660                 }
1661                 lilv_instance_connect_port(_impl->instance, port_index, buf);
1662         }
1663
1664         // Read messages from UI and push into appropriate buffers
1665         if (_from_ui) {
1666                 uint32_t read_space = _from_ui->read_space();
1667                 while (read_space > sizeof(UIMessage)) {
1668                         UIMessage msg;
1669                         if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1670                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1671                                 break;
1672                         }
1673                         uint8_t body[msg.size];
1674                         if (_from_ui->read(body, msg.size) != msg.size) {
1675                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1676                                 break;
1677                         }
1678                         if (msg.protocol == urids.atom_eventTransfer) {
1679                                 LV2_Evbuf*            buf  = _ev_buffers[msg.index];
1680                                 LV2_Evbuf_Iterator    i    = lv2_evbuf_end(buf);
1681                                 const LV2_Atom* const atom = (const LV2_Atom*)body;
1682                                 if (!lv2_evbuf_write(&i, nframes, 0, atom->type, atom->size,
1683                                                 (const uint8_t*)(atom + 1))) {
1684                                         error << "Failed to write data to LV2 event buffer\n";
1685                                 }
1686                         } else {
1687                                 error << "Received unknown message type from UI" << endmsg;
1688                         }
1689                         read_space -= sizeof(UIMessage) + msg.size;
1690                 }
1691         }
1692
1693         run(nframes);
1694
1695         midi_out_index = 0;
1696         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1697                 PortFlags flags = _port_flags[port_index];
1698                 bool      valid = false;
1699
1700                 /* TODO ask drobilla about comment
1701                  * "Make Ardour event buffers generic so plugins can communicate"
1702                  * in libs/ardour/buffer_set.cc:310
1703                  *
1704                  * ideally the user could choose which of the following two modes
1705                  * to use (e.g. instrument/effect chains  MIDI OUT vs MIDI TRHU).
1706                  *
1707                  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
1708                  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
1709                  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
1710                  *                            for quite a while at least ;)
1711                  */
1712                 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
1713                 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
1714                         const uint32_t buf_index = out_map.get(
1715                                 DataType::MIDI, midi_out_index++, &valid);
1716                         if (valid) {
1717                                 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
1718                         }
1719                 }
1720                 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
1721                 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
1722                         const uint32_t buf_index = out_map.get(
1723                                 DataType::MIDI, midi_out_index++, &valid);
1724                         if (valid) {
1725                                 bufs.flush_lv2_midi(true, buf_index);
1726                         }
1727                 }
1728
1729                 // Write messages to UI
1730                 if (_to_ui && (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
1731                         LV2_Evbuf* buf = _ev_buffers[port_index];
1732                         for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
1733                              lv2_evbuf_is_valid(i);
1734                              i = lv2_evbuf_next(i)) {
1735                                 uint32_t frames, subframes, type, size;
1736                                 uint8_t* data;
1737                                 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
1738                                 write_to_ui(port_index, urids.atom_eventTransfer,
1739                                             size + sizeof(LV2_Atom),
1740                                             data - sizeof(LV2_Atom));
1741                         }
1742                 }
1743         }
1744
1745         cycles_t now = get_cycles();
1746         set_cycles((uint32_t)(now - then));
1747
1748         // Update expected transport information for next cycle so we can detect changes
1749         _next_cycle_speed = _session.transport_speed();
1750         _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
1751
1752         return 0;
1753 }
1754
1755 bool
1756 LV2Plugin::parameter_is_control(uint32_t param) const
1757 {
1758         assert(param < _port_flags.size());
1759         return _port_flags[param] & PORT_CONTROL;
1760 }
1761
1762 bool
1763 LV2Plugin::parameter_is_audio(uint32_t param) const
1764 {
1765         assert(param < _port_flags.size());
1766         return _port_flags[param] & PORT_AUDIO;
1767 }
1768
1769 bool
1770 LV2Plugin::parameter_is_event(uint32_t param) const
1771 {
1772         assert(param < _port_flags.size());
1773         return _port_flags[param] & PORT_EVENT;
1774 }
1775
1776 bool
1777 LV2Plugin::parameter_is_output(uint32_t param) const
1778 {
1779         assert(param < _port_flags.size());
1780         return _port_flags[param] & PORT_OUTPUT;
1781 }
1782
1783 bool
1784 LV2Plugin::parameter_is_input(uint32_t param) const
1785 {
1786         assert(param < _port_flags.size());
1787         return _port_flags[param] & PORT_INPUT;
1788 }
1789
1790 void
1791 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
1792 {
1793         if (buf && len) {
1794                 if (param < parameter_count()) {
1795                         snprintf(buf, len, "%.3f", get_parameter(param));
1796                 } else {
1797                         strcat(buf, "0");
1798                 }
1799         }
1800 }
1801
1802 boost::shared_ptr<Plugin::ScalePoints>
1803 LV2Plugin::get_scale_points(uint32_t port_index) const
1804 {
1805         const LilvPort*  port   = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
1806         LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
1807
1808         boost::shared_ptr<Plugin::ScalePoints> ret;
1809         if (!points) {
1810                 return ret;
1811         }
1812
1813         ret = boost::shared_ptr<Plugin::ScalePoints>(new ScalePoints());
1814
1815         LILV_FOREACH(scale_points, i, points) {
1816                 const LilvScalePoint* p     = lilv_scale_points_get(points, i);
1817                 const LilvNode*       label = lilv_scale_point_get_label(p);
1818                 const LilvNode*       value = lilv_scale_point_get_value(p);
1819                 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
1820                         ret->insert(make_pair(lilv_node_as_string(label),
1821                                               lilv_node_as_float(value)));
1822                 }
1823         }
1824
1825         lilv_scale_points_free(points);
1826         return ret;
1827 }
1828
1829 void
1830 LV2Plugin::run(pframes_t nframes)
1831 {
1832         uint32_t const N = parameter_count();
1833         for (uint32_t i = 0; i < N; ++i) {
1834                 if (parameter_is_control(i) && parameter_is_input(i)) {
1835                         _control_data[i] = _shadow_data[i];
1836                 }
1837         }
1838
1839         lilv_instance_run(_impl->instance, nframes);
1840
1841         if (_impl->work_iface) {
1842                 _worker->emit_responses();
1843                 if (_impl->work_iface->end_run) {
1844                         _impl->work_iface->end_run(_impl->instance->lv2_handle);
1845                 }
1846         }
1847 }
1848
1849 void
1850 LV2Plugin::latency_compute_run()
1851 {
1852         if (!_latency_control_port) {
1853                 return;
1854         }
1855
1856         // Run the plugin so that it can set its latency parameter
1857
1858         activate();
1859
1860         uint32_t port_index = 0;
1861         uint32_t in_index   = 0;
1862         uint32_t out_index  = 0;
1863
1864         const framecnt_t bufsize = 1024;
1865         float            buffer[bufsize];
1866
1867         memset(buffer, 0, sizeof(float) * bufsize);
1868
1869         // FIXME: Ensure plugins can handle in-place processing
1870
1871         port_index = 0;
1872
1873         while (port_index < parameter_count()) {
1874                 if (parameter_is_audio(port_index)) {
1875                         if (parameter_is_input(port_index)) {
1876                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
1877                                 in_index++;
1878                         } else if (parameter_is_output(port_index)) {
1879                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
1880                                 out_index++;
1881                         }
1882                 }
1883                 port_index++;
1884         }
1885
1886         run(bufsize);
1887         deactivate();
1888 }
1889
1890 const LilvPort*
1891 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
1892 {
1893         const LilvPort* port = NULL;
1894         LilvNode* designation = lilv_new_uri(_world.world, uri);
1895         port = lilv_plugin_get_port_by_designation(
1896                 plugin, _world.lv2_InputPort, designation);
1897         lilv_node_free(designation);
1898         if (port) {
1899                 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
1900         }
1901         return port;
1902 }
1903
1904 static bool lv2_filter (const string& str, void *arg)
1905 {
1906         /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
1907
1908         return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
1909 }
1910
1911
1912 LV2World::LV2World()
1913         : world(lilv_world_new())
1914         , _bundle_checked(false)
1915 {
1916         lilv_world_load_all(world);
1917
1918         atom_AtomPort      = lilv_new_uri(world, LV2_ATOM__AtomPort);
1919         atom_Chunk         = lilv_new_uri(world, LV2_ATOM__Chunk);
1920         atom_Sequence      = lilv_new_uri(world, LV2_ATOM__Sequence);
1921         atom_bufferType    = lilv_new_uri(world, LV2_ATOM__bufferType);
1922         atom_supports      = lilv_new_uri(world, LV2_ATOM__supports);
1923         atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
1924         ev_EventPort       = lilv_new_uri(world, LILV_URI_EVENT_PORT);
1925         ext_logarithmic    = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
1926         ext_notOnGUI       = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
1927         lv2_AudioPort      = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
1928         lv2_ControlPort    = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
1929         lv2_InputPort      = lilv_new_uri(world, LILV_URI_INPUT_PORT);
1930         lv2_OutputPort     = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
1931         lv2_inPlaceBroken  = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
1932         lv2_integer        = lilv_new_uri(world, LV2_CORE__integer);
1933         lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
1934         lv2_sampleRate     = lilv_new_uri(world, LV2_CORE__sampleRate);
1935         lv2_toggled        = lilv_new_uri(world, LV2_CORE__toggled);
1936         lv2_enumeration    = lilv_new_uri(world, LV2_CORE__enumeration);
1937         lv2_freewheeling   = lilv_new_uri(world, LV2_CORE__freeWheeling);
1938         midi_MidiEvent     = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
1939         rdfs_comment       = lilv_new_uri(world, LILV_NS_RDFS "comment");
1940         rsz_minimumSize    = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
1941         time_Position      = lilv_new_uri(world, LV2_TIME__Position);
1942         ui_GtkUI           = lilv_new_uri(world, LV2_UI__GtkUI);
1943         ui_external        = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
1944 }
1945
1946 LV2World::~LV2World()
1947 {
1948         lilv_node_free(ui_external);
1949         lilv_node_free(ui_GtkUI);
1950         lilv_node_free(time_Position);
1951         lilv_node_free(rsz_minimumSize);
1952         lilv_node_free(rdfs_comment);
1953         lilv_node_free(midi_MidiEvent);
1954         lilv_node_free(lv2_enumeration);
1955         lilv_node_free(lv2_freewheeling);
1956         lilv_node_free(lv2_toggled);
1957         lilv_node_free(lv2_sampleRate);
1958         lilv_node_free(lv2_reportsLatency);
1959         lilv_node_free(lv2_integer);
1960         lilv_node_free(lv2_inPlaceBroken);
1961         lilv_node_free(lv2_OutputPort);
1962         lilv_node_free(lv2_InputPort);
1963         lilv_node_free(lv2_ControlPort);
1964         lilv_node_free(lv2_AudioPort);
1965         lilv_node_free(ext_notOnGUI);
1966         lilv_node_free(ext_logarithmic);
1967         lilv_node_free(ev_EventPort);
1968         lilv_node_free(atom_supports);
1969         lilv_node_free(atom_eventTransfer);
1970         lilv_node_free(atom_bufferType);
1971         lilv_node_free(atom_Sequence);
1972         lilv_node_free(atom_Chunk);
1973         lilv_node_free(atom_AtomPort);
1974 }
1975
1976 void
1977 LV2World::load_bundled_plugins()
1978 {
1979         if (!_bundle_checked) {
1980                 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
1981                 PathScanner scanner;
1982                 vector<string *> *plugin_objects = scanner (ARDOUR::lv2_bundled_search_path().to_string(), lv2_filter, 0, true, true);
1983                 if (plugin_objects) {
1984                         for ( vector<string *>::iterator x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
1985 #ifdef WINDOWS
1986                                 string uri = "file:///" + **x + "/";
1987 #else
1988                                 string uri = "file://" + **x + "/";
1989 #endif
1990                                 LilvNode *node = lilv_new_uri(world, uri.c_str());
1991                                 lilv_world_load_bundle(world, node);
1992                                 lilv_node_free(node);
1993                         }
1994                 }
1995                 delete (plugin_objects);
1996
1997                 _bundle_checked = true;
1998         }
1999 }
2000
2001 LV2PluginInfo::LV2PluginInfo (const void* c_plugin)
2002         : _c_plugin(c_plugin)
2003 {
2004         type = ARDOUR::LV2;
2005 }
2006
2007 LV2PluginInfo::~LV2PluginInfo()
2008 {}
2009
2010 PluginPtr
2011 LV2PluginInfo::load(Session& session)
2012 {
2013         try {
2014                 PluginPtr plugin;
2015
2016                 plugin.reset(new LV2Plugin(session.engine(), session,
2017                                            (const LilvPlugin*)_c_plugin,
2018                                            session.frame_rate()));
2019
2020                 plugin->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
2021                 return plugin;
2022         } catch (failed_constructor& err) {
2023                 return PluginPtr((Plugin*)0);
2024         }
2025
2026         return PluginPtr();
2027 }
2028
2029 PluginInfoList*
2030 LV2PluginInfo::discover()
2031 {
2032         _world.load_bundled_plugins();
2033
2034         PluginInfoList*    plugs   = new PluginInfoList;
2035         const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2036
2037         info << "LV2: Discovering " << lilv_plugins_size(plugins) << " plugins" << endmsg;
2038
2039         LILV_FOREACH(plugins, i, plugins) {
2040                 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2041                 LV2PluginInfoPtr  info(new LV2PluginInfo((const void*)p));
2042
2043                 LilvNode* name = lilv_plugin_get_name(p);
2044                 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2045                         warning << "Ignoring invalid LV2 plugin "
2046                                 << lilv_node_as_string(lilv_plugin_get_uri(p))
2047                                 << endmsg;
2048                         continue;
2049                 }
2050
2051                 info->type = LV2;
2052
2053                 info->name = string(lilv_node_as_string(name));
2054                 lilv_node_free(name);
2055
2056                 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2057                 const LilvNode*        label  = lilv_plugin_class_get_label(pclass);
2058                 info->category = lilv_node_as_string(label);
2059
2060                 LilvNode* author_name = lilv_plugin_get_author_name(p);
2061                 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2062                 lilv_node_free(author_name);
2063
2064                 info->path = "/NOPATH"; // Meaningless for LV2
2065
2066                 /* count atom-event-ports that feature
2067                  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2068                  *
2069                  * TODO: nicely ask drobilla to make a lilv_ call for that
2070                  */
2071                 int count_midi_out = 0;
2072                 int count_midi_in = 0;
2073                 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2074                         const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
2075                         if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2076                                 LilvNodes* buffer_types = lilv_port_get_value(
2077                                         p, port, _world.atom_bufferType);
2078                                 LilvNodes* atom_supports = lilv_port_get_value(
2079                                         p, port, _world.atom_supports);
2080
2081                                 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)
2082                                                 && lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
2083                                         if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2084                                                 count_midi_in++;
2085                                         }
2086                                         if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2087                                                 count_midi_out++;
2088                                         }
2089                                 }
2090                                 lilv_nodes_free(buffer_types);
2091                                 lilv_nodes_free(atom_supports);
2092                         }
2093                 }
2094
2095                 info->n_inputs.set_audio(
2096                         lilv_plugin_get_num_ports_of_class(
2097                                 p, _world.lv2_InputPort, _world.lv2_AudioPort, NULL));
2098                 info->n_inputs.set_midi(
2099                         lilv_plugin_get_num_ports_of_class(
2100                                 p, _world.lv2_InputPort, _world.ev_EventPort, NULL)
2101                         + count_midi_in);
2102
2103                 info->n_outputs.set_audio(
2104                         lilv_plugin_get_num_ports_of_class(
2105                                 p, _world.lv2_OutputPort, _world.lv2_AudioPort, NULL));
2106                 info->n_outputs.set_midi(
2107                         lilv_plugin_get_num_ports_of_class(
2108                                 p, _world.lv2_OutputPort, _world.ev_EventPort, NULL)
2109                         + count_midi_out);
2110
2111                 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2112                 info->index     = 0; // Meaningless for LV2
2113
2114                 plugs->push_back(info);
2115         }
2116
2117         return plugs;
2118 }