libs/ardour/lv2_plugin.cc

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