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 <cctype>
  21 #include <string>
  22 #include <vector>
  23 #include <limits>
  24
  25 #include <cmath>
  26 #include <cstdlib>
  27 #include <cstring>
  28
  29 #include "pbd/gstdio_compat.h"
  30 #include <glib/gprintf.h>
  31 #include <glibmm.h>
  32
  33 #include <boost/utility.hpp>
  34
  35 #include "pbd/file_utils.h"
  36 #include "pbd/stl_delete.h"
  37 #include "pbd/compose.h"
  38 #include "pbd/error.h"
  39 #include "pbd/replace_all.h"
  40 #include "pbd/xml++.h"
  41
  42 #include "libardour-config.h"
  43
  44 #include "ardour/audio_buffer.h"
  45 #include "ardour/audioengine.h"
  46 #include "ardour/debug.h"
  47 #include "ardour/lv2_plugin.h"
  48 #include "ardour/midi_patch_manager.h"
  49 #include "ardour/session.h"
  50 #include "ardour/tempo.h"
  51 #include "ardour/types.h"
  52 #include "ardour/utils.h"
  53 #include "ardour/worker.h"
  54 #include "ardour/search_paths.h"
  55
  56 #include "pbd/i18n.h"
  57 #include <locale.h>
  58
  59 #include <lilv/lilv.h>
  60
  61 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
  62 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
  63 #include "lv2/lv2plug.in/ns/ext/log/log.h"
  64 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
  65 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
  66 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
  67 #include "lv2/lv2plug.in/ns/ext/state/state.h"
  68 #include "lv2/lv2plug.in/ns/ext/time/time.h"
  69 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
  70 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
  71 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
  72 #include "lv2/lv2plug.in/ns/extensions/units/units.h"
  73 #include "lv2/lv2plug.in/ns/ext/patch/patch.h"
  74 #include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
  75 #ifdef HAVE_LV2_1_2_0
  76 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
  77 #include "lv2/lv2plug.in/ns/ext/options/options.h"
  78 #endif
  79
  80 #include "lv2_evbuf.h"
  81
  82 #ifdef HAVE_SUIL
  83 #include <suil/suil.h>
  84 #endif
  85
  86 // Compatibility for old LV2
  87 #ifndef LV2_ATOM_CONTENTS_CONST
  88 #define LV2_ATOM_CONTENTS_CONST(type, atom) \
  89         ((const void*)((const uint8_t*)(atom) + sizeof(type)))
  90 #endif
  91 #ifndef LV2_ATOM_BODY_CONST
  92 #define LV2_ATOM_BODY_CONST(atom) LV2_ATOM_CONTENTS_CONST(LV2_Atom, atom)
  93 #endif
  94 #ifndef LV2_PATCH__property
  95 #define LV2_PATCH__property LV2_PATCH_PREFIX "property"
  96 #endif
  97 #ifndef LV2_PATCH__value
  98 #define LV2_PATCH__value LV2_PATCH_PREFIX "value"
  99 #endif
 100 #ifndef LV2_PATCH__writable
 101 #define LV2_PATCH__writable LV2_PATCH_PREFIX "writable"
 102 #endif
 103
 104 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
 105     This needs to be roughly the number of cycles the UI will get around to
 106     actually processing the traffic.  Lower values are flakier but save memory.
 107 */
 108 static const size_t NBUFS = 4;
 109
 110 using namespace std;
 111 using namespace ARDOUR;
 112 using namespace PBD;
 113
 114 bool LV2Plugin::force_state_save = false;
 115
 116 class LV2World : boost::noncopyable {
 117 public:
 118         LV2World ();
 119         ~LV2World ();
 120
 121         void load_bundled_plugins(bool verbose=false);
 122
 123         LilvWorld* world;
 124
 125         LilvNode* atom_AtomPort;
 126         LilvNode* atom_Chunk;
 127         LilvNode* atom_Sequence;
 128         LilvNode* atom_bufferType;
 129         LilvNode* atom_eventTransfer;
 130         LilvNode* atom_supports;
 131         LilvNode* ev_EventPort;
 132         LilvNode* ext_logarithmic;
 133         LilvNode* ext_notOnGUI;
 134         LilvNode* ext_expensive;
 135         LilvNode* ext_causesArtifacts;
 136         LilvNode* ext_notAutomatic;
 137         LilvNode* ext_rangeSteps;
 138         LilvNode* groups_group;
 139         LilvNode* groups_element;
 140         LilvNode* lv2_AudioPort;
 141         LilvNode* lv2_ControlPort;
 142         LilvNode* lv2_InputPort;
 143         LilvNode* lv2_OutputPort;
 144         LilvNode* lv2_designation;
 145         LilvNode* lv2_enumeration;
 146         LilvNode* lv2_freewheeling;
 147         LilvNode* lv2_inPlaceBroken;
 148         LilvNode* lv2_isSideChain;
 149         LilvNode* lv2_index;
 150         LilvNode* lv2_integer;
 151         LilvNode* lv2_default;
 152         LilvNode* lv2_minimum;
 153         LilvNode* lv2_maximum;
 154         LilvNode* lv2_reportsLatency;
 155         LilvNode* lv2_sampleRate;
 156         LilvNode* lv2_toggled;
 157         LilvNode* midi_MidiEvent;
 158         LilvNode* rdfs_comment;
 159         LilvNode* rdfs_label;
 160         LilvNode* rdfs_range;
 161         LilvNode* rsz_minimumSize;
 162         LilvNode* time_Position;
 163         LilvNode* ui_GtkUI;
 164         LilvNode* ui_external;
 165         LilvNode* ui_externalkx;
 166         LilvNode* units_hz;
 167         LilvNode* units_db;
 168         LilvNode* units_unit;
 169         LilvNode* units_render;
 170         LilvNode* units_midiNote;
 171         LilvNode* patch_writable;
 172         LilvNode* patch_Message;
 173 #ifdef HAVE_LV2_1_2_0
 174         LilvNode* bufz_powerOf2BlockLength;
 175         LilvNode* bufz_fixedBlockLength;
 176         LilvNode* bufz_nominalBlockLength;
 177         LilvNode* bufz_coarseBlockLength;
 178 #endif
 179
 180 #ifdef HAVE_LV2_1_10_0
 181         LilvNode* atom_int;
 182         LilvNode* atom_float;
 183         LilvNode* atom_object; // new in 1.8
 184         LilvNode* atom_vector;
 185 #endif
 186 #ifdef LV2_EXTENDED
 187         LilvNode* lv2_noSampleAccurateCtrl;
 188         LilvNode* auto_can_write_automatation; // lv2:optionalFeature
 189         LilvNode* auto_automation_control; // atom:supports
 190         LilvNode* auto_automation_controlled; // lv2:portProperty
 191         LilvNode* auto_automation_controller; // lv2:portProperty
 192 #endif
 193
 194 private:
 195         bool _bundle_checked;
 196 };
 197
 198 static LV2World _world;
 199
 200 /* worker extension */
 201
 202 /** Called by the plugin to schedule non-RT work. */
 203 static LV2_Worker_Status
 204 work_schedule(LV2_Worker_Schedule_Handle handle,
 205               uint32_t                   size,
 206               const void*                data)
 207 {
 208         return (((Worker*)handle)->schedule(size, data)
 209                 ? LV2_WORKER_SUCCESS
 210                 : LV2_WORKER_ERR_UNKNOWN);
 211 }
 212
 213 /** Called by the plugin to respond to non-RT work. */
 214 static LV2_Worker_Status
 215 work_respond(LV2_Worker_Respond_Handle handle,
 216              uint32_t                  size,
 217              const void*               data)
 218 {
 219         return (((Worker*)handle)->respond(size, data)
 220                 ? LV2_WORKER_SUCCESS
 221                 : LV2_WORKER_ERR_UNKNOWN);
 222 }
 223
 224 #ifdef LV2_EXTENDED
 225 /* inline display extension */
 226 static void
 227 queue_draw (LV2_Inline_Display_Handle handle)
 228 {
 229         LV2Plugin* plugin = (LV2Plugin*)handle;
 230         plugin->QueueDraw(); /* EMIT SIGNAL */
 231 }
 232
 233 static void
 234 midnam_update (LV2_Midnam_Handle handle)
 235 {
 236         LV2Plugin* plugin = (LV2Plugin*)handle;
 237         plugin->UpdateMidnam (); /* EMIT SIGNAL */
 238 }
 239 #endif
 240
 241 /* log extension */
 242
 243 static int
 244 log_vprintf(LV2_Log_Handle /*handle*/,
 245             LV2_URID       type,
 246             const char*    fmt,
 247             va_list        args)
 248 {
 249         char* str = NULL;
 250         const int ret = g_vasprintf(&str, fmt, args);
 251         /* strip trailing whitespace */
 252         while (strlen (str) > 0 && isspace (str[strlen (str) - 1])) {
 253                 str[strlen (str) - 1] = '\0';
 254         }
 255         if (strlen (str) == 0) {
 256                 return 0;
 257         }
 258
 259         if (type == URIMap::instance().urids.log_Error) {
 260                 error << str << endmsg;
 261         } else if (type == URIMap::instance().urids.log_Warning) {
 262                 warning << str << endmsg;
 263         } else if (type == URIMap::instance().urids.log_Note) {
 264                 info << str << endmsg;
 265         } else if (type == URIMap::instance().urids.log_Trace) {
 266                 DEBUG_TRACE(DEBUG::LV2, str);
 267         }
 268         return ret;
 269 }
 270
 271 static int
 272 log_printf(LV2_Log_Handle handle,
 273            LV2_URID       type,
 274            const char*    fmt, ...)
 275 {
 276         va_list args;
 277         va_start(args, fmt);
 278         const int ret = log_vprintf(handle, type, fmt, args);
 279         va_end(args);
 280         return ret;
 281 }
 282
 283 struct LV2Plugin::Impl {
 284         Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
 285                , work_iface(0)
 286 #ifdef HAVE_LV2_1_2_0
 287                , opts_iface(0)
 288 #endif
 289                , state(0)
 290                , block_length(0)
 291 #ifdef HAVE_LV2_1_2_0
 292                , options(0)
 293 #endif
 294 #ifdef LV2_EXTENDED
 295                , queue_draw(0)
 296                , midnam(0)
 297 #endif
 298         {}
 299
 300         /** Find the LV2 input port with the given designation.
 301          * If found, bufptrs[port_index] will be set to bufptr.
 302          */
 303         const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
 304
 305         const LilvPlugin*            plugin;
 306         const LilvUI*                ui;
 307         const LilvNode*              ui_type;
 308         LilvNode*                    name;
 309         LilvNode*                    author;
 310         LilvInstance*                instance;
 311         const LV2_Worker_Interface*  work_iface;
 312 #ifdef HAVE_LV2_1_2_0
 313         const LV2_Options_Interface* opts_iface;
 314 #endif
 315         LilvState*                   state;
 316         LV2_Atom_Forge               forge;
 317         LV2_Atom_Forge               ui_forge;
 318         int32_t                      block_length;
 319 #ifdef HAVE_LV2_1_2_0
 320         LV2_Options_Option*          options;
 321 #endif
 322 #ifdef LV2_EXTENDED
 323         LV2_Inline_Display*          queue_draw;
 324         LV2_Midnam*                  midnam;
 325 #endif
 326 };
 327
 328 LV2Plugin::LV2Plugin (AudioEngine& engine,
 329                       Session&     session,
 330                       const void*  c_plugin,
 331                       framecnt_t   rate)
 332         : Plugin (engine, session)
 333         , Workee ()
 334         , _impl(new Impl())
 335         , _features(NULL)
 336         , _worker(NULL)
 337         , _state_worker(NULL)
 338         , _insert_id("0")
 339         , _patch_port_in_index((uint32_t)-1)
 340         , _patch_port_out_index((uint32_t)-1)
 341         , _uri_map(URIMap::instance())
 342         , _no_sample_accurate_ctrl (false)
 343 {
 344         init(c_plugin, rate);
 345 }
 346
 347 LV2Plugin::LV2Plugin (const LV2Plugin& other)
 348         : Plugin (other)
 349         , Workee ()
 350         , _impl(new Impl())
 351         , _features(NULL)
 352         , _worker(NULL)
 353         , _state_worker(NULL)
 354         , _insert_id(other._insert_id)
 355         , _patch_port_in_index((uint32_t)-1)
 356         , _patch_port_out_index((uint32_t)-1)
 357         , _uri_map(URIMap::instance())
 358         , _no_sample_accurate_ctrl (false)
 359 {
 360         init(other._impl->plugin, other._sample_rate);
 361
 362         for (uint32_t i = 0; i < parameter_count(); ++i) {
 363                 _control_data[i] = other._shadow_data[i];
 364                 _shadow_data[i]  = other._shadow_data[i];
 365         }
 366 }
 367
 368 void
 369 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
 370 {
 371         DEBUG_TRACE(DEBUG::LV2, "init\n");
 372
 373         _impl->plugin           = (const LilvPlugin*)c_plugin;
 374         _impl->ui               = NULL;
 375         _impl->ui_type          = NULL;
 376         _to_ui                  = NULL;
 377         _from_ui                = NULL;
 378         _control_data           = 0;
 379         _shadow_data            = 0;
 380         _atom_ev_buffers        = 0;
 381         _ev_buffers             = 0;
 382         _bpm_control_port       = 0;
 383         _freewheel_control_port = 0;
 384         _latency_control_port   = 0;
 385         _next_cycle_start       = std::numeric_limits<framepos_t>::max();
 386         _next_cycle_speed       = 1.0;
 387         _seq_size               = _engine.raw_buffer_size(DataType::MIDI);
 388         _state_version          = 0;
 389         _was_activated          = false;
 390         _has_state_interface    = false;
 391         _can_write_automation   = false;
 392         _max_latency            = 0;
 393         _current_latency        = 0;
 394         _impl->block_length     = _session.get_block_size();
 395
 396         _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
 397         _data_access_feature.URI     = "http://lv2plug.in/ns/ext/data-access";
 398         _make_path_feature.URI       = LV2_STATE__makePath;
 399         _log_feature.URI             = LV2_LOG__log;
 400         _work_schedule_feature.URI   = LV2_WORKER__schedule;
 401         _work_schedule_feature.data  = NULL;
 402         _def_state_feature.URI       = LV2_STATE_PREFIX "loadDefaultState";  // Post LV2-1.2.0
 403         _def_state_feature.data      = NULL;
 404
 405         const LilvPlugin* plugin = _impl->plugin;
 406
 407         LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
 408         LilvNode* state_uri       = lilv_new_uri(_world.world, LV2_STATE_URI);
 409         _has_state_interface =
 410                 // What plugins should have (lv2:extensionData state:Interface)
 411                 lilv_plugin_has_extension_data(plugin, state_iface_uri)
 412                 // What some outdated/incorrect ones have
 413                 || lilv_plugin_has_feature(plugin, state_uri);
 414         lilv_node_free(state_uri);
 415         lilv_node_free(state_iface_uri);
 416
 417         _features    = (LV2_Feature**)calloc(13, sizeof(LV2_Feature*));
 418         _features[0] = &_instance_access_feature;
 419         _features[1] = &_data_access_feature;
 420         _features[2] = &_make_path_feature;
 421         _features[3] = _uri_map.uri_map_feature();
 422         _features[4] = _uri_map.urid_map_feature();
 423         _features[5] = _uri_map.urid_unmap_feature();
 424         _features[6] = &_log_feature;
 425
 426         unsigned n_features = 7;
 427 #ifdef HAVE_LV2_1_2_0
 428         _features[n_features++] = &_def_state_feature;
 429 #endif
 430
 431         lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
 432         lv2_atom_forge_init(&_impl->ui_forge, _uri_map.urid_map());
 433
 434 #ifdef LV2_EXTENDED
 435         _impl->queue_draw = (LV2_Inline_Display*)
 436                 malloc (sizeof(LV2_Inline_Display));
 437         _impl->queue_draw->handle     = this;
 438         _impl->queue_draw->queue_draw = queue_draw;
 439
 440         _queue_draw_feature.URI  = LV2_INLINEDISPLAY__queue_draw;
 441         _queue_draw_feature.data = _impl->queue_draw;
 442         _features[n_features++]  = &_queue_draw_feature;
 443
 444         _impl->midnam = (LV2_Midnam*)
 445                 malloc (sizeof(LV2_Midnam));
 446         _impl->midnam->handle = this;
 447         _impl->midnam->update = midnam_update;
 448
 449         _midnam_feature.URI  = LV2_MIDNAM__update;
 450         _midnam_feature.data = _impl->midnam;
 451         _features[n_features++]  = &_midnam_feature;
 452 #endif
 453
 454 #ifdef HAVE_LV2_1_2_0
 455         LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
 456         static const int32_t _min_block_length = 1;   // may happen during split-cycles
 457         static const int32_t _max_block_length = 8192; // max possible (with all engines and during export)
 458         /* Consider updating max-block-size whenever the buffersize changes.
 459          * It requires re-instantiating the plugin (which is a non-realtime operation),
 460          * so it should be done lightly and only for plugins that require it.
 461          *
 462          * given that the block-size can change at any time (split-cycles) ardour currently
 463          * does not support plugins that require bufz_fixedBlockLength.
 464          */
 465         LV2_Options_Option options[] = {
 466                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
 467                   sizeof(int32_t), atom_Int, &_min_block_length },
 468                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
 469                   sizeof(int32_t), atom_Int, &_max_block_length },
 470                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
 471                   sizeof(int32_t), atom_Int, &_seq_size },
 472                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
 473                   sizeof(int32_t), atom_Int, &_impl->block_length },
 474                 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
 475         };
 476
 477         _impl->options = (LV2_Options_Option*) malloc (sizeof (options));
 478         memcpy ((void*) _impl->options, (void*) options, sizeof (options));
 479
 480         _options_feature.URI    = LV2_OPTIONS__options;
 481         _options_feature.data   = _impl->options;
 482         _features[n_features++] = &_options_feature;
 483 #endif
 484
 485         LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
 486                 sizeof(LV2_State_Make_Path));
 487         make_path->handle = this;
 488         make_path->path = &lv2_state_make_path;
 489         _make_path_feature.data = make_path;
 490
 491         LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
 492         log->handle  = this;
 493         log->printf  = &log_printf;
 494         log->vprintf = &log_vprintf;
 495         _log_feature.data = log;
 496
 497         const size_t ring_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
 498         LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
 499         if (lilv_plugin_has_feature(plugin, worker_schedule)) {
 500                 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
 501                         sizeof(LV2_Worker_Schedule));
 502                 _worker                     = new Worker(this, ring_size);
 503                 schedule->handle            = _worker;
 504                 schedule->schedule_work     = work_schedule;
 505                 _work_schedule_feature.data = schedule;
 506                 _features[n_features++]     = &_work_schedule_feature;
 507         }
 508         lilv_node_free(worker_schedule);
 509
 510         if (_has_state_interface) {
 511                 // Create a non-threaded worker for use by state restore
 512                 _state_worker = new Worker(this, ring_size, false);
 513         }
 514
 515         _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
 516         _impl->name     = lilv_plugin_get_name(plugin);
 517         _impl->author   = lilv_plugin_get_author_name(plugin);
 518
 519         if (_impl->instance == 0) {
 520                 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
 521                 throw failed_constructor();
 522         }
 523
 524         _instance_access_feature.data              = (void*)_impl->instance->lv2_handle;
 525         _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
 526         _data_access_feature.data                  = &_data_access_extension_data;
 527
 528         LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
 529         if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
 530                 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
 531                         LV2_WORKER__interface);
 532         }
 533         lilv_node_free(worker_iface_uri);
 534
 535
 536 #ifdef HAVE_LV2_1_2_0
 537         LilvNode* options_iface_uri = lilv_new_uri(_world.world, LV2_OPTIONS__interface);
 538         if (lilv_plugin_has_extension_data(plugin, options_iface_uri)) {
 539                 _impl->opts_iface = (const LV2_Options_Interface*)extension_data(
 540                         LV2_OPTIONS__interface);
 541         }
 542         lilv_node_free(options_iface_uri);
 543 #endif
 544
 545 #ifdef LV2_EXTENDED
 546         _display_interface = (const LV2_Inline_Display_Interface*)
 547                 extension_data (LV2_INLINEDISPLAY__interface);
 548
 549         _midname_interface = (const LV2_Midnam_Interface*)
 550                 extension_data (LV2_MIDNAM__interface);
 551         if (_midname_interface) {
 552                 read_midnam ();
 553         }
 554 #endif
 555
 556         if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
 557                 error << string_compose(
 558                     _("LV2: \"%1\" cannot be used, since it cannot do inplace processing."),
 559                     lilv_node_as_string(_impl->name)) << endmsg;
 560                 lilv_node_free(_impl->name);
 561                 lilv_node_free(_impl->author);
 562                 throw failed_constructor();
 563         }
 564
 565 #ifdef HAVE_LV2_1_2_0
 566         LilvNodes *required_features = lilv_plugin_get_required_features (plugin);
 567         if (lilv_nodes_contains (required_features, _world.bufz_powerOf2BlockLength) ||
 568                         lilv_nodes_contains (required_features, _world.bufz_fixedBlockLength)
 569            ) {
 570                 error << string_compose(
 571                     _("LV2: \"%1\" buffer-size requirements cannot be satisfied."),
 572                     lilv_node_as_string(_impl->name)) << endmsg;
 573                 lilv_node_free(_impl->name);
 574                 lilv_node_free(_impl->author);
 575                 lilv_nodes_free(required_features);
 576                 throw failed_constructor();
 577         }
 578         lilv_nodes_free(required_features);
 579 #endif
 580
 581         LilvNodes* optional_features = lilv_plugin_get_optional_features (plugin);
 582 #ifdef HAVE_LV2_1_2_0
 583         if (lilv_nodes_contains (optional_features, _world.bufz_coarseBlockLength)) {
 584                 _no_sample_accurate_ctrl = true;
 585         }
 586 #endif
 587 #ifdef LV2_EXTENDED
 588         if (lilv_nodes_contains (optional_features, _world.lv2_noSampleAccurateCtrl)) {
 589                 /* deprecated 2016-Sep-18 in favor of bufz_coarseBlockLength */
 590                 _no_sample_accurate_ctrl = true;
 591         }
 592         if (lilv_nodes_contains (optional_features, _world.auto_can_write_automatation)) {
 593                 _can_write_automation = true;
 594         }
 595         lilv_nodes_free(optional_features);
 596 #endif
 597
 598 #ifdef HAVE_LILV_0_16_0
 599         // Load default state
 600         if (_worker) {
 601                 /* immediately schedule any work,
 602                  * so that state restore later will not find a busy
 603                  * worker.  latency_compute_run() flushes any replies
 604                  */
 605                 _worker->set_synchronous(true);
 606         }
 607         LilvState* state = lilv_state_new_from_world(
 608                 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
 609         if (state && _has_state_interface) {
 610                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
 611         }
 612         lilv_state_free(state);
 613 #endif
 614
 615         _sample_rate = rate;
 616
 617         const uint32_t num_ports = this->num_ports();
 618         for (uint32_t i = 0; i < num_ports; ++i) {
 619                 const LilvPort* port  = lilv_plugin_get_port_by_index(_impl->plugin, i);
 620                 PortFlags       flags = 0;
 621                 size_t          minimumSize = 0;
 622
 623                 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
 624                         flags |= PORT_OUTPUT;
 625                 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
 626                         flags |= PORT_INPUT;
 627                 } else {
 628                         error << string_compose(
 629                                 "LV2: \"%1\" port %2 is neither input nor output",
 630                                 lilv_node_as_string(_impl->name), i) << endmsg;
 631                         throw failed_constructor();
 632                 }
 633
 634                 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
 635                         flags |= PORT_CONTROL;
 636                 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
 637                         flags |= PORT_AUDIO;
 638                 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
 639                         flags |= PORT_EVENT;
 640                         flags |= PORT_MIDI;  // We assume old event API ports are for MIDI
 641                 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
 642                         LilvNodes* buffer_types = lilv_port_get_value(
 643                                 _impl->plugin, port, _world.atom_bufferType);
 644                         LilvNodes* atom_supports = lilv_port_get_value(
 645                                 _impl->plugin, port, _world.atom_supports);
 646
 647                         if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
 648                                 flags |= PORT_SEQUENCE;
 649                                 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
 650                                         flags |= PORT_MIDI;
 651                                 }
 652                                 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
 653                                         flags |= PORT_POSITION;
 654                                 }
 655 #ifdef LV2_EXTENDED
 656                                 if (lilv_nodes_contains(atom_supports, _world.auto_automation_control)) {
 657                                         flags |= PORT_AUTOCTRL;
 658                                 }
 659 #endif
 660                                 if (lilv_nodes_contains(atom_supports, _world.patch_Message)) {
 661                                         flags |= PORT_PATCHMSG;
 662                                         if (flags & PORT_INPUT) {
 663                                                 _patch_port_in_index = i;
 664                                         } else {
 665                                                 _patch_port_out_index = i;
 666                                         }
 667                                 }
 668                         }
 669                         LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
 670                         LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
 671                         if (min_size && lilv_node_is_int(min_size)) {
 672                                 minimumSize = lilv_node_as_int(min_size);
 673                         }
 674                         lilv_nodes_free(min_size_v);
 675                         lilv_nodes_free(buffer_types);
 676                         lilv_nodes_free(atom_supports);
 677                 } else {
 678                         error << string_compose(
 679                                 "LV2: \"%1\" port %2 has no known data type",
 680                                 lilv_node_as_string(_impl->name), i) << endmsg;
 681                         throw failed_constructor();
 682                 }
 683
 684                 if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
 685                         if (lilv_port_has_property(_impl->plugin, port, _world.ext_causesArtifacts)) {
 686                                 flags |= PORT_NOAUTO;
 687                         }
 688                         if (lilv_port_has_property(_impl->plugin, port, _world.ext_notAutomatic)) {
 689                                 flags |= PORT_NOAUTO;
 690                         }
 691                         if (lilv_port_has_property(_impl->plugin, port, _world.ext_expensive)) {
 692                                 flags |= PORT_NOAUTO;
 693                         }
 694                 }
 695 #ifdef LV2_EXTENDED
 696                 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controlled)) {
 697                         if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
 698                                 flags |= PORT_CTRLED;
 699                         }
 700                 }
 701                 if (lilv_port_has_property(_impl->plugin, port, _world.auto_automation_controller)) {
 702                         if ((flags & PORT_INPUT) && (flags & PORT_CONTROL)) {
 703                                 flags |= PORT_CTRLER;
 704                         }
 705                 }
 706 #endif
 707
 708                 _port_flags.push_back(flags);
 709                 _port_minimumSize.push_back(minimumSize);
 710                 DEBUG_TRACE(DEBUG::LV2, string_compose("port %1 buffer %2 bytes\n", i, minimumSize));
 711         }
 712
 713         _control_data = new float[num_ports];
 714         _shadow_data  = new float[num_ports];
 715         _defaults     = new float[num_ports];
 716         _ev_buffers   = new LV2_Evbuf*[num_ports];
 717         memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
 718
 719         const bool     latent        = lilv_plugin_has_latency(plugin);
 720         const uint32_t latency_index = (latent)
 721                 ? lilv_plugin_get_latency_port_index(plugin)
 722                 : 0;
 723
 724         // Build an array of pointers to special parameter buffers
 725         void*** params = new void**[num_ports];
 726         for (uint32_t i = 0; i < num_ports; ++i) {
 727                 params[i] = NULL;
 728         }
 729         _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
 730         _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
 731
 732         for (uint32_t i = 0; i < num_ports; ++i) {
 733                 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
 734                 const LilvNode* sym  = lilv_port_get_symbol(plugin, port);
 735
 736                 // Store index in map so we can look up index by symbol
 737                 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
 738
 739                 // Get range and default value if applicable
 740                 if (parameter_is_control(i)) {
 741                         LilvNode* def;
 742                         lilv_port_get_range(plugin, port, &def, NULL, NULL);
 743                         _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
 744                         if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
 745                                 _defaults[i] *= _session.frame_rate ();
 746                         }
 747                         lilv_node_free(def);
 748
 749                         lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
 750
 751                         if (latent && i == latency_index) {
 752                                 LilvNode *max;
 753                                 lilv_port_get_range(_impl->plugin, port, NULL, NULL, &max);
 754                                 _max_latency = max ? lilv_node_as_float(max) : .02 * _sample_rate;
 755                                 _latency_control_port  = &_control_data[i];
 756                                 *_latency_control_port = 0;
 757                         }
 758
 759                         if (parameter_is_input(i)) {
 760                                 _shadow_data[i] = default_value(i);
 761                                 if (params[i]) {
 762                                         *params[i] = (void*)&_shadow_data[i];
 763                                 }
 764                         }
 765                 } else {
 766                         _defaults[i] = 0.0f;
 767                 }
 768         }
 769
 770         delete[] params;
 771
 772         LilvUIs* uis = lilv_plugin_get_uis(plugin);
 773         if (lilv_uis_size(uis) > 0) {
 774 #ifdef HAVE_SUIL
 775                 // Look for embeddable UI
 776                 LILV_FOREACH(uis, u, uis) {
 777                         const LilvUI*   this_ui      = lilv_uis_get(uis, u);
 778                         const LilvNode* this_ui_type = NULL;
 779                         if (lilv_ui_is_supported(this_ui,
 780                                                  suil_ui_supported,
 781                                                  _world.ui_GtkUI,
 782                                                  &this_ui_type)) {
 783                                 // TODO: Multiple UI support
 784                                 _impl->ui      = this_ui;
 785                                 _impl->ui_type = this_ui_type;
 786                                 break;
 787                         }
 788                 }
 789 #else
 790                 // Look for Gtk native UI
 791                 LILV_FOREACH(uis, i, uis) {
 792                         const LilvUI* ui = lilv_uis_get(uis, i);
 793                         if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
 794                                 _impl->ui      = ui;
 795                                 _impl->ui_type = _world.ui_GtkUI;
 796                                 break;
 797                         }
 798                 }
 799 #endif
 800
 801                 // If Gtk UI is not available, try to find external UI
 802                 if (!_impl->ui) {
 803                         LILV_FOREACH(uis, i, uis) {
 804                                 const LilvUI* ui = lilv_uis_get(uis, i);
 805                                 if (lilv_ui_is_a(ui, _world.ui_externalkx)) {
 806                                         _impl->ui      = ui;
 807                                         _impl->ui_type = _world.ui_external;
 808                                         break;
 809                                 }
 810                                 if (lilv_ui_is_a(ui, _world.ui_external)) {
 811                                         _impl->ui      = ui;
 812                                         _impl->ui_type = _world.ui_external;
 813                                 }
 814                         }
 815                 }
 816         }
 817
 818         load_supported_properties(_property_descriptors);
 819         allocate_atom_event_buffers();
 820         latency_compute_run();
 821 }
 822
 823 int
 824 LV2Plugin::set_block_size (pframes_t nframes)
 825 {
 826 #ifdef HAVE_LV2_1_2_0
 827         if (_impl->opts_iface) {
 828                 LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
 829                 _impl->block_length = nframes;
 830                 LV2_Options_Option block_size_option = {
 831                         LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id ("http://lv2plug.in/ns/ext/buf-size#nominalBlockLength"),
 832                         sizeof(int32_t), atom_Int, (void*)&_impl->block_length
 833                 };
 834                 _impl->opts_iface->set (_impl->instance->lv2_handle, &block_size_option);
 835         }
 836 #endif
 837         return 0;
 838 }
 839
 840 bool
 841 LV2Plugin::requires_fixed_sized_buffers () const
 842 {
 843         /* This controls if Ardour will split the plugin's run()
 844          * on automation events in order to pass sample-accurate automation
 845          * via standard control-ports.
 846          *
 847          * When returning true Ardour will *not* sub-divide the process-cycle.
 848          * Automation events that happen between cycle-start and cycle-end will be
 849          * ignored (ctrl values are interpolated to cycle-start).
 850          * NB. Atom Sequences are still sample accurate.
 851          *
 852          * Note: This does not guarantee a fixed block-size.
 853          * e.g The process cycle may be split when looping, also
 854          * the period-size may change any time: see set_block_size()
 855          */
 856         if (get_info()->n_inputs.n_midi() > 0) {
 857                 /* we don't yet implement midi buffer offsets (for split cycles).
 858                  * Also connect_and_run() also uses _session.transport_frame() directly
 859                  * (for BBT) which is not offset for plugin cycle split.
 860                  */
 861                 return true;
 862         }
 863         return _no_sample_accurate_ctrl;
 864 }
 865
 866 LV2Plugin::~LV2Plugin ()
 867 {
 868         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
 869
 870         deactivate();
 871         cleanup();
 872
 873 #ifdef LV2_EXTENDED
 874         if (has_midnam ()) {
 875                 std::stringstream ss;
 876                 ss << (void*)this;
 877                 ss << unique_id();
 878                 MIDI::Name::MidiPatchManager::instance().remove_custom_midnam (ss.str());
 879         }
 880 #endif
 881
 882         lilv_instance_free(_impl->instance);
 883         lilv_state_free(_impl->state);
 884         lilv_node_free(_impl->name);
 885         lilv_node_free(_impl->author);
 886 #ifdef HAVE_LV2_1_2_0
 887         free(_impl->options);
 888 #endif
 889 #ifdef LV2_EXTENDED
 890         free(_impl->queue_draw);
 891         free(_impl->midnam);
 892 #endif
 893
 894         free(_features);
 895         free(_log_feature.data);
 896         free(_make_path_feature.data);
 897         free(_work_schedule_feature.data);
 898
 899         delete _to_ui;
 900         delete _from_ui;
 901         delete _worker;
 902         delete _state_worker;
 903
 904         if (_atom_ev_buffers) {
 905                 LV2_Evbuf**  b = _atom_ev_buffers;
 906                 while (*b) {
 907                         free(*b);
 908                         b++;
 909                 }
 910                 free(_atom_ev_buffers);
 911         }
 912
 913         delete [] _control_data;
 914         delete [] _shadow_data;
 915         delete [] _defaults;
 916         delete [] _ev_buffers;
 917         delete _impl;
 918 }
 919
 920 bool
 921 LV2Plugin::is_external_ui() const
 922 {
 923         if (!_impl->ui) {
 924                 return false;
 925         }
 926         return lilv_ui_is_a(_impl->ui, _world.ui_external) || lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
 927 }
 928
 929 bool
 930 LV2Plugin::is_external_kx() const
 931 {
 932         if (!_impl->ui) {
 933                 return false;
 934         }
 935         return lilv_ui_is_a(_impl->ui, _world.ui_externalkx);
 936 }
 937
 938 bool
 939 LV2Plugin::ui_is_resizable () const
 940 {
 941         const LilvNode* s   = lilv_ui_get_uri(_impl->ui);
 942         LilvNode*       p   = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
 943         LilvNode*       fs  = lilv_new_uri(_world.world, LV2_UI__fixedSize);
 944         LilvNode*       nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
 945
 946         LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
 947         LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
 948
 949         lilv_nodes_free(nrs_matches);
 950         lilv_nodes_free(fs_matches);
 951         lilv_node_free(nrs);
 952         lilv_node_free(fs);
 953         lilv_node_free(p);
 954
 955         return !fs_matches && !nrs_matches;
 956 }
 957
 958 #ifdef LV2_EXTENDED
 959 bool
 960 LV2Plugin::has_inline_display () {
 961         return _display_interface ? true : false;
 962 }
 963
 964 Plugin::Display_Image_Surface*
 965 LV2Plugin::render_inline_display (uint32_t w, uint32_t h) {
 966         if (_display_interface) {
 967                 /* Plugin::Display_Image_Surface is identical to
 968                  * LV2_Inline_Display_Image_Surface */
 969                 return (Plugin::Display_Image_Surface*) _display_interface->render ((void*)_impl->instance->lv2_handle, w, h);
 970         }
 971         return NULL;
 972 }
 973
 974 bool
 975 LV2Plugin::has_midnam () {
 976         return _midname_interface ? true : false;
 977 }
 978
 979 bool
 980 LV2Plugin::read_midnam () {
 981         bool rv = false;
 982         if (!_midname_interface) {
 983                 return rv;
 984         }
 985         char* midnam = _midname_interface->midnam ((void*)_impl->instance->lv2_handle);
 986         if (midnam) {
 987                 std::stringstream ss;
 988                 ss << (void*)this;
 989                 ss << unique_id();
 990                 rv = MIDI::Name::MidiPatchManager::instance().update_custom_midnam (ss.str(), midnam);
 991         }
 992 #ifndef NDEBUG
 993         if (rv) {
 994                 info << string_compose(_("LV2: update midnam for plugin '%1'"), name ()) << endmsg;
 995         } else {
 996                 warning << string_compose(_("LV2: Failed to parse midnam of plugin '%1'"), name ()) << endmsg;
 997         }
 998 #endif
 999         _midname_interface->free (midnam);
1000         return rv;
1001 }
1002
1003 std::string
1004 LV2Plugin::midnam_model () {
1005         std::string rv;
1006         if (!_midname_interface) {
1007                 return rv;
1008         }
1009         char* model = _midname_interface->model ((void*)_impl->instance->lv2_handle);
1010         if (model) {
1011                 rv = model;
1012         }
1013         _midname_interface->free (model);
1014         return rv;
1015 }
1016 #endif
1017
1018 string
1019 LV2Plugin::unique_id() const
1020 {
1021         return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1022 }
1023
1024 const char*
1025 LV2Plugin::uri() const
1026 {
1027         return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
1028 }
1029
1030 const char*
1031 LV2Plugin::label() const
1032 {
1033         return lilv_node_as_string(_impl->name);
1034 }
1035
1036 const char*
1037 LV2Plugin::name() const
1038 {
1039         return lilv_node_as_string(_impl->name);
1040 }
1041
1042 const char*
1043 LV2Plugin::maker() const
1044 {
1045         return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
1046 }
1047
1048 uint32_t
1049 LV2Plugin::num_ports() const
1050 {
1051         return lilv_plugin_get_num_ports(_impl->plugin);
1052 }
1053
1054 uint32_t
1055 LV2Plugin::parameter_count() const
1056 {
1057         return lilv_plugin_get_num_ports(_impl->plugin);
1058 }
1059
1060 float
1061 LV2Plugin::default_value(uint32_t port)
1062 {
1063         return _defaults[port];
1064 }
1065
1066 const char*
1067 LV2Plugin::port_symbol(uint32_t index) const
1068 {
1069         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
1070         if (!port) {
1071                 error << name() << ": Invalid port index " << index << endmsg;
1072         }
1073
1074         const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
1075         return lilv_node_as_string(sym);
1076 }
1077
1078 uint32_t
1079 LV2Plugin::port_index (const char* symbol) const
1080 {
1081         const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
1082         if (i != _port_indices.end()) {
1083                 return  i->second;
1084         } else {
1085                 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
1086                 return (uint32_t)-1;
1087         }
1088 }
1089
1090 void
1091 LV2Plugin::set_parameter(uint32_t which, float val)
1092 {
1093         DEBUG_TRACE(DEBUG::LV2, string_compose(
1094                             "%1 set parameter %2 to %3\n", name(), which, val));
1095
1096         if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
1097                 if (get_parameter (which) == val) {
1098                         return;
1099                 }
1100
1101                 _shadow_data[which] = val;
1102         } else {
1103                 warning << string_compose(
1104                     _("Illegal parameter number used with plugin \"%1\". "
1105                       "This is a bug in either %2 or the LV2 plugin <%3>"),
1106                     name(), PROGRAM_NAME, unique_id()) << endmsg;
1107         }
1108
1109         Plugin::set_parameter(which, val);
1110 }
1111
1112 float
1113 LV2Plugin::get_parameter(uint32_t which) const
1114 {
1115         if (parameter_is_input(which)) {
1116                 return (float)_shadow_data[which];
1117         } else {
1118                 return (float)_control_data[which];
1119         }
1120         return 0.0f;
1121 }
1122
1123 std::string
1124 LV2Plugin::get_docs() const
1125 {
1126         LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
1127         if (comments) {
1128                 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1129                 lilv_nodes_free(comments);
1130                 return docs;
1131         }
1132
1133         return "";
1134 }
1135
1136 std::string
1137 LV2Plugin::get_parameter_docs(uint32_t which) const
1138 {
1139         LilvNodes* comments = lilv_port_get_value(
1140                 _impl->plugin,
1141                 lilv_plugin_get_port_by_index(_impl->plugin, which),
1142                 _world.rdfs_comment);
1143
1144         if (comments) {
1145                 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
1146                 lilv_nodes_free(comments);
1147                 return docs;
1148         }
1149
1150         return "";
1151 }
1152
1153 bool
1154 LV2Plugin::get_layout (uint32_t which, UILayoutHint& h) const
1155 {
1156         /// TODO lookup port-properties
1157         if (unique_id () != "urn:ardour:a-eq") {
1158                 return false;
1159         }
1160         h.knob = true;
1161         switch (which) {
1162                 case  0: h.x0 = 0; h.x1 = 1; h.y0 = 2; h.y1 = 3; break; // Frequency L
1163                 case  1: h.x0 = 0; h.x1 = 1; h.y0 = 0; h.y1 = 1; break; // Gain L
1164                 case 17: h.x0 = 0; h.x1 = 1; h.y0 = 5; h.y1 = 6; break; // enable L
1165
1166                 case  2: h.x0 = 1; h.x1 = 3; h.y0 = 2; h.y1 = 3; break; // Frequency 1
1167                 case  3: h.x0 = 1; h.x1 = 3; h.y0 = 0; h.y1 = 1; break; // Gain 1
1168                 case  4: h.x0 = 2; h.x1 = 4; h.y0 = 1; h.y1 = 2; break; // Bandwidth 1
1169                 case 18: h.x0 = 1; h.x1 = 4; h.y0 = 5; h.y1 = 6; break; // enable 1
1170
1171                 case  5: h.x0 = 4; h.x1 = 6; h.y0 = 2; h.y1 = 3; break; // Frequency 2
1172                 case  6: h.x0 = 4; h.x1 = 6; h.y0 = 0; h.y1 = 1; break; // Gain 2
1173                 case  7: h.x0 = 5; h.x1 = 7; h.y0 = 1; h.y1 = 2; break; // Bandwidth 2
1174                 case 19: h.x0 = 4; h.x1 = 7; h.y0 = 5; h.y1 = 6; break; // enable 2
1175
1176                 case  8: h.x0 = 7; h.x1 =  9; h.y0 = 2; h.y1 = 3; break; // Frequency 3
1177                 case  9: h.x0 = 7; h.x1 =  9; h.y0 = 0; h.y1 = 1; break; // Gain 3
1178                 case 10: h.x0 = 8; h.x1 = 10; h.y0 = 1; h.y1 = 2; break; // Bandwidth 3
1179                 case 20: h.x0 = 7; h.x1 = 10; h.y0 = 5; h.y1 = 6; break; // enable 3
1180
1181                 case 11: h.x0 = 10; h.x1 = 12; h.y0 = 2; h.y1 = 3; break; // Frequency 4
1182                 case 12: h.x0 = 10; h.x1 = 12; h.y0 = 0; h.y1 = 1; break; // Gain 4
1183                 case 13: h.x0 = 11; h.x1 = 13; h.y0 = 1; h.y1 = 2; break; // Bandwidth 4
1184                 case 21: h.x0 = 10; h.x1 = 13; h.y0 = 5; h.y1 = 6; break; // enable 4
1185
1186                 case 14: h.x0 = 13; h.x1 = 14; h.y0 = 2; h.y1 = 3; break; // Frequency H
1187                 case 15: h.x0 = 13; h.x1 = 14; h.y0 = 0; h.y1 = 1; break; // Gain H
1188                 case 22: h.x0 = 13; h.x1 = 14; h.y0 = 5; h.y1 = 6; break; // enable H
1189
1190                 case 16: h.x0 = 14; h.x1 = 15; h.y0 = 1; h.y1 = 3; break; // Master Gain
1191                 case 23: h.x0 = 14; h.x1 = 15; h.y0 = 5; h.y1 = 6; break; // Master Enable
1192                 default:
1193                         return false;
1194         }
1195         return true;
1196 }
1197
1198 uint32_t
1199 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
1200 {
1201         ok = false;
1202         for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
1203                 if (parameter_is_control(x)) {
1204                         if (c++ == n) {
1205                                 ok = true;
1206                                 return x;
1207                         }
1208                 }
1209         }
1210
1211         return 0;
1212 }
1213
1214 const void*
1215 LV2Plugin::extension_data(const char* uri) const
1216 {
1217         return lilv_instance_get_extension_data(_impl->instance, uri);
1218 }
1219
1220 const void*
1221 LV2Plugin::c_plugin()
1222 {
1223         return _impl->plugin;
1224 }
1225
1226 const void*
1227 LV2Plugin::c_ui()
1228 {
1229         return (const void*)_impl->ui;
1230 }
1231
1232 const void*
1233 LV2Plugin::c_ui_type()
1234 {
1235         return (const void*)_impl->ui_type;
1236 }
1237
1238 /** Directory for all plugin state. */
1239 const std::string
1240 LV2Plugin::plugin_dir() const
1241 {
1242         if (!_plugin_state_dir.empty ()){
1243                 return Glib::build_filename(_plugin_state_dir, _insert_id.to_s());
1244         } else {
1245                 return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
1246         }
1247 }
1248
1249 /** Directory for files created by the plugin (except during save). */
1250 const std::string
1251 LV2Plugin::scratch_dir() const
1252 {
1253         return Glib::build_filename(plugin_dir(), "scratch");
1254 }
1255
1256 /** Directory for snapshots of files in the scratch directory. */
1257 const std::string
1258 LV2Plugin::file_dir() const
1259 {
1260         return Glib::build_filename(plugin_dir(), "files");
1261 }
1262
1263 /** Directory to save state snapshot version @c num into. */
1264 const std::string
1265 LV2Plugin::state_dir(unsigned num) const
1266 {
1267         return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
1268 }
1269
1270 /** Implementation of state:makePath for files created at instantiation time.
1271  * Note this is not used for files created at save time (Lilv deals with that).
1272  */
1273 char*
1274 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
1275                                const char*                path)
1276 {
1277         LV2Plugin* me = (LV2Plugin*)handle;
1278         if (me->_insert_id == PBD::ID("0")) {
1279                 warning << string_compose(
1280                         "File path \"%1\" requested but LV2 %2 has no insert ID",
1281                         path, me->name()) << endmsg;
1282                 return g_strdup(path);
1283         }
1284
1285         const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
1286         const std::string dirname  = Glib::path_get_dirname(abs_path);
1287         g_mkdir_with_parents(dirname.c_str(), 0744);
1288
1289         DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
1290                                                path, abs_path));
1291
1292         return g_strndup(abs_path.c_str(), abs_path.length());
1293 }
1294
1295 void
1296 LV2Plugin::add_state(XMLNode* root) const
1297 {
1298         assert(_insert_id != PBD::ID("0"));
1299
1300         XMLNode*    child;
1301         char        buf[32];
1302         LocaleGuard lg;
1303
1304         for (uint32_t i = 0; i < parameter_count(); ++i) {
1305                 if (parameter_is_input(i) && parameter_is_control(i)) {
1306                         child = new XMLNode("Port");
1307                         child->add_property("symbol", port_symbol(i));
1308                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
1309                         child->add_property("value", string(buf));
1310                         root->add_child_nocopy(*child);
1311                 }
1312         }
1313
1314         if (!_plugin_state_dir.empty()) {
1315                 root->add_property("template-dir", _plugin_state_dir);
1316         }
1317
1318         if (_has_state_interface) {
1319                 // Provisionally increment state version and create directory
1320                 const std::string new_dir = state_dir(++_state_version);
1321                 // and keep track of it (for templates & archive)
1322                 unsigned int saved_state = _state_version;;
1323                 g_mkdir_with_parents(new_dir.c_str(), 0744);
1324
1325                 LilvState* state = lilv_state_new_from_instance(
1326                         _impl->plugin,
1327                         _impl->instance,
1328                         _uri_map.urid_map(),
1329                         scratch_dir().c_str(),
1330                         file_dir().c_str(),
1331                         _session.externals_dir().c_str(),
1332                         new_dir.c_str(),
1333                         NULL,
1334                         const_cast<LV2Plugin*>(this),
1335                         0,
1336                         NULL);
1337
1338                 if (!_plugin_state_dir.empty() || force_state_save
1339                     || !_impl->state
1340                     || !lilv_state_equals(state, _impl->state)) {
1341                         lilv_state_save(_world.world,
1342                                         _uri_map.urid_map(),
1343                                         _uri_map.urid_unmap(),
1344                                         state,
1345                                         NULL,
1346                                         new_dir.c_str(),
1347                                         "state.ttl");
1348
1349                         if (force_state_save) {
1350                                 // archive or save-as
1351                                 lilv_state_free(state);
1352                                 --_state_version;
1353                         }
1354                         else if (_plugin_state_dir.empty()) {
1355                                 // normal session save
1356                                 lilv_state_free(_impl->state);
1357                                 _impl->state = state;
1358                         } else {
1359                                 // template save (dedicated state-dir)
1360                                 lilv_state_free(state);
1361                                 --_state_version;
1362                         }
1363                 } else {
1364                         // State is identical, decrement version and nuke directory
1365                         lilv_state_free(state);
1366                         PBD::remove_directory(new_dir);
1367                         --_state_version;
1368                         saved_state = _state_version;
1369                 }
1370
1371                 root->add_property("state-dir", string_compose("state%1", saved_state));
1372         }
1373 }
1374
1375 // TODO: Once we can rely on lilv 0.16.0, lilv_world_get can replace this
1376 static LilvNode*
1377 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
1378 {
1379         LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
1380         if (vs) {
1381                 LilvNode* node = lilv_node_duplicate(lilv_nodes_get_first(vs));
1382                 lilv_nodes_free(vs);
1383                 return node;
1384         }
1385         return NULL;
1386 }
1387
1388 void
1389 LV2Plugin::find_presets()
1390 {
1391         LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
1392         LilvNode* pset_Preset   = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
1393         LilvNode* rdfs_label    = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
1394
1395         LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
1396         LILV_FOREACH(nodes, i, presets) {
1397                 const LilvNode* preset = lilv_nodes_get(presets, i);
1398                 lilv_world_load_resource(_world.world, preset);
1399                 LilvNode* name = get_value(_world.world, preset, rdfs_label);
1400                 bool userpreset = true; // TODO
1401                 if (name) {
1402                         _presets.insert(std::make_pair(lilv_node_as_string(preset),
1403                                                        Plugin::PresetRecord(
1404                                                                lilv_node_as_string(preset),
1405                                                                lilv_node_as_string(name),
1406                                                                userpreset)));
1407                         lilv_node_free(name);
1408                 } else {
1409                         warning << string_compose(
1410                             _("Plugin \"%1\" preset \"%2\" is missing a label\n"),
1411                             lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
1412                             lilv_node_as_string(preset)) << endmsg;
1413                 }
1414         }
1415         lilv_nodes_free(presets);
1416
1417         lilv_node_free(rdfs_label);
1418         lilv_node_free(pset_Preset);
1419         lilv_node_free(lv2_appliesTo);
1420 }
1421
1422 static void
1423 set_port_value(const char* port_symbol,
1424                void*       user_data,
1425                const void* value,
1426                uint32_t    /*size*/,
1427                uint32_t    type)
1428 {
1429         LV2Plugin* self = (LV2Plugin*)user_data;
1430         if (type != 0 && type != URIMap::instance().urids.atom_Float) {
1431                 return;  // TODO: Support non-float ports
1432         }
1433
1434         const uint32_t port_index = self->port_index(port_symbol);
1435         if (port_index != (uint32_t)-1) {
1436                 self->set_parameter(port_index, *(const float*)value);
1437                 self->PresetPortSetValue (port_index, *(const float*)value); /* EMIT SIGNAL */
1438         }
1439 }
1440
1441 bool
1442 LV2Plugin::load_preset(PresetRecord r)
1443 {
1444         LilvWorld* world = _world.world;
1445         LilvNode*  pset  = lilv_new_uri(world, r.uri.c_str());
1446         LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1447
1448         const LV2_Feature*  state_features[2]   = { NULL, NULL };
1449         LV2_Worker_Schedule schedule            = { _state_worker, work_schedule };
1450         const LV2_Feature   state_sched_feature = { LV2_WORKER__schedule, &schedule };
1451         if (_state_worker) {
1452                 state_features[0] = &state_sched_feature;
1453         }
1454
1455         if (state) {
1456                 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, state_features);
1457                 lilv_state_free(state);
1458                 Plugin::load_preset(r);
1459         }
1460
1461         lilv_node_free(pset);
1462         return state;
1463 }
1464
1465 const void*
1466 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1467                                  void*       user_data,
1468                                  uint32_t*   size,
1469                                  uint32_t*   type)
1470 {
1471         LV2Plugin *plugin = (LV2Plugin *) user_data;
1472
1473         uint32_t index = plugin->port_index(port_symbol);
1474         if (index != (uint32_t) -1) {
1475                 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1476                         float *value;
1477                         *size = sizeof(float);
1478                         *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1479                         value = &plugin->_shadow_data[index];
1480
1481                         return value;
1482                 }
1483         }
1484
1485         *size = *type = 0;
1486         return NULL;
1487 }
1488
1489
1490 std::string
1491 LV2Plugin::do_save_preset(string name)
1492 {
1493         LilvNode*    plug_name = lilv_plugin_get_name(_impl->plugin);
1494         const string prefix    = legalize_for_uri(lilv_node_as_string(plug_name));
1495         const string base_name = legalize_for_uri(name);
1496         const string file_name = base_name + ".ttl";
1497         const string bundle    = Glib::build_filename(
1498                 Glib::get_home_dir(),
1499                 Glib::build_filename(".lv2", prefix + "_" + base_name + ".lv2"));
1500
1501 #ifdef HAVE_LILV_0_21_3
1502         /* delete reference to old preset (if any) */
1503         const PresetRecord* r = preset_by_label(name);
1504         if (r) {
1505                 LilvNode*  pset  = lilv_new_uri (_world.world, r->uri.c_str());
1506                 if (pset) {
1507                         lilv_world_unload_resource (_world.world, pset);
1508                         lilv_node_free(pset);
1509                 }
1510         }
1511 #endif
1512
1513         LilvState* state = lilv_state_new_from_instance(
1514                 _impl->plugin,
1515                 _impl->instance,
1516                 _uri_map.urid_map(),
1517                 scratch_dir().c_str(),                   // file_dir
1518                 bundle.c_str(),                          // copy_dir
1519                 bundle.c_str(),                          // link_dir
1520                 bundle.c_str(),                          // save_dir
1521                 lv2plugin_get_port_value,                // get_value
1522                 (void*)this,                             // user_data
1523                 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE,  // flags
1524                 _features                                // features
1525         );
1526
1527         lilv_state_set_label(state, name.c_str());
1528         lilv_state_save(
1529                 _world.world,           // world
1530                 _uri_map.urid_map(),    // map
1531                 _uri_map.urid_unmap(),  // unmap
1532                 state,                  // state
1533                 NULL,                   // uri (NULL = use file URI)
1534                 bundle.c_str(),         // dir
1535                 file_name.c_str()       // filename
1536         );
1537
1538         lilv_state_free(state);
1539
1540         std::string uri = Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1541         LilvNode *node_bundle = lilv_new_uri(_world.world, Glib::filename_to_uri(Glib::build_filename(bundle, "/")).c_str());
1542         LilvNode *node_preset = lilv_new_uri(_world.world, uri.c_str());
1543 #ifdef HAVE_LILV_0_21_3
1544         lilv_world_unload_resource(_world.world, node_preset);
1545         lilv_world_unload_bundle(_world.world, node_bundle);
1546 #endif
1547         lilv_world_load_bundle(_world.world, node_bundle);
1548         lilv_world_load_resource(_world.world, node_preset);
1549         lilv_node_free(node_bundle);
1550         lilv_node_free(node_preset);
1551         lilv_node_free(plug_name);
1552         return uri;
1553 }
1554
1555 void
1556 LV2Plugin::do_remove_preset(string name)
1557 {
1558 #ifdef HAVE_LILV_0_21_3
1559         /* Look up preset record by label (FIXME: ick, label as ID) */
1560         const PresetRecord* r = preset_by_label(name);
1561         if (!r) {
1562                 return;
1563         }
1564
1565         /* Load a LilvState for the preset. */
1566         LilvWorld* world = _world.world;
1567         LilvNode*  pset  = lilv_new_uri(world, r->uri.c_str());
1568         LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1569         if (!state) {
1570                 lilv_node_free(pset);
1571                 return;
1572         }
1573
1574         /* Unload preset from world. */
1575         lilv_world_unload_resource(world, pset);
1576
1577         /* Delete it from the file system.  This will remove the preset file and the entry
1578            from the manifest.  If this results in an empty manifest (i.e. the
1579            preset is the only thing in the bundle), then the bundle is removed. */
1580         lilv_state_delete(world, state);
1581
1582         lilv_state_free(state);
1583         lilv_node_free(pset);
1584 #endif
1585         /* Without lilv_state_delete(), we could delete the preset file, but this
1586            would leave a broken bundle/manifest around, so the preset would still
1587            be visible, but broken.  Naively deleting a bundle is too dangerous, so
1588            we simply do not support preset deletion with older Lilv */
1589 }
1590
1591 bool
1592 LV2Plugin::has_editor() const
1593 {
1594         return _impl->ui != NULL;
1595 }
1596
1597 bool
1598 LV2Plugin::has_message_output() const
1599 {
1600         for (uint32_t i = 0; i < num_ports(); ++i) {
1601                 if ((_port_flags[i] & PORT_SEQUENCE) &&
1602                     (_port_flags[i] & PORT_OUTPUT)) {
1603                         return true;
1604                 }
1605         }
1606         return false;
1607 }
1608
1609 bool
1610 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1611                     uint32_t             index,
1612                     uint32_t             protocol,
1613                     uint32_t             size,
1614                     const uint8_t*       body)
1615 {
1616         const uint32_t  buf_size = sizeof(UIMessage) + size;
1617         vector<uint8_t> buf(buf_size);
1618
1619         UIMessage* msg = (UIMessage*)&buf[0];
1620         msg->index    = index;
1621         msg->protocol = protocol;
1622         msg->size     = size;
1623         memcpy(msg + 1, body, size);
1624
1625         return (dest->write(&buf[0], buf_size) == buf_size);
1626 }
1627
1628 bool
1629 LV2Plugin::write_from_ui(uint32_t       index,
1630                          uint32_t       protocol,
1631                          uint32_t       size,
1632                          const uint8_t* body)
1633 {
1634         if (!_from_ui) {
1635                 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1636                 /* buffer data communication from plugin UI to plugin instance.
1637                  * this buffer needs to potentially hold
1638                  *   (port's minimumSize) * (audio-periods) / (UI-periods)
1639                  * bytes.
1640                  *
1641                  *  e.g 48kSPS / 128fpp -> audio-periods = 375 Hz
1642                  *  ui-periods = 25 Hz (SuperRapidScreenUpdate)
1643                  *  default minimumSize = 32K (see LV2Plugin::allocate_atom_event_buffers()
1644                  *
1645                  * it is NOT safe to overflow (msg.size will be misinterpreted)
1646                  */
1647                 uint32_t bufsiz = 32768;
1648                 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1649                         bufsiz =  lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1650                 }
1651                 int fact = ceilf(_session.frame_rate () / 3000.f);
1652                 rbs = max((size_t) bufsiz * std::max (8, fact), rbs);
1653                 _from_ui = new RingBuffer<uint8_t>(rbs);
1654         }
1655
1656         if (!write_to(_from_ui, index, protocol, size, body)) {
1657                 error << "Error writing from UI to plugin" << endmsg;
1658                 return false;
1659         }
1660         return true;
1661 }
1662
1663 bool
1664 LV2Plugin::write_to_ui(uint32_t       index,
1665                        uint32_t       protocol,
1666                        uint32_t       size,
1667                        const uint8_t* body)
1668 {
1669         if (!write_to(_to_ui, index, protocol, size, body)) {
1670                 error << "Error writing from plugin to UI" << endmsg;
1671                 return false;
1672         }
1673         return true;
1674 }
1675
1676 static void
1677 forge_variant(LV2_Atom_Forge* forge, const Variant& value)
1678 {
1679         switch (value.type()) {
1680         case Variant::NOTHING:
1681                 break;
1682         case Variant::BEATS:
1683                 // No atom type for this, just forge a double
1684                 lv2_atom_forge_double(forge, value.get_beats().to_double());
1685                 break;
1686         case Variant::BOOL:
1687                 lv2_atom_forge_bool(forge, value.get_bool());
1688                 break;
1689         case Variant::DOUBLE:
1690                 lv2_atom_forge_double(forge, value.get_double());
1691                 break;
1692         case Variant::FLOAT:
1693                 lv2_atom_forge_float(forge, value.get_float());
1694                 break;
1695         case Variant::INT:
1696                 lv2_atom_forge_int(forge, value.get_int());
1697                 break;
1698         case Variant::LONG:
1699                 lv2_atom_forge_long(forge, value.get_long());
1700                 break;
1701         case Variant::PATH:
1702                 lv2_atom_forge_path(
1703                         forge, value.get_path().c_str(), value.get_path().size());
1704                 break;
1705         case Variant::STRING:
1706                 lv2_atom_forge_string(
1707                         forge, value.get_string().c_str(), value.get_string().size());
1708                 break;
1709         case Variant::URI:
1710                 lv2_atom_forge_uri(
1711                         forge, value.get_uri().c_str(), value.get_uri().size());
1712                 break;
1713         }
1714 }
1715
1716 /** Get a variant type from a URI, return false iff no match found. */
1717 static bool
1718 uri_to_variant_type(const std::string& uri, Variant::Type& type)
1719 {
1720         if (uri == LV2_ATOM__Bool) {
1721                 type = Variant::BOOL;
1722         } else if (uri == LV2_ATOM__Double) {
1723                 type = Variant::DOUBLE;
1724         } else if (uri == LV2_ATOM__Float) {
1725                 type = Variant::FLOAT;
1726         } else if (uri == LV2_ATOM__Int) {
1727                 type = Variant::INT;
1728         } else if (uri == LV2_ATOM__Long) {
1729                 type = Variant::LONG;
1730         } else if (uri == LV2_ATOM__Path) {
1731                 type = Variant::PATH;
1732         } else if (uri == LV2_ATOM__String) {
1733                 type = Variant::STRING;
1734         } else if (uri == LV2_ATOM__URI) {
1735                 type = Variant::URI;
1736         } else {
1737                 return false;
1738         }
1739         return true;
1740 }
1741
1742 void
1743 LV2Plugin::set_property(uint32_t key, const Variant& value)
1744 {
1745         if (_patch_port_in_index == (uint32_t)-1) {
1746                 error << "LV2: set_property called with unset patch_port_in_index" << endmsg;
1747                 return;
1748         } else if (value.type() == Variant::NOTHING) {
1749                 error << "LV2: set_property called with void value" << endmsg;
1750                 return;
1751         }
1752
1753         // Set up forge to write to temporary buffer on the stack
1754         LV2_Atom_Forge*      forge = &_impl->ui_forge;
1755         LV2_Atom_Forge_Frame frame;
1756         uint8_t              buf[PATH_MAX];  // Ought to be enough for anyone...
1757
1758         lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1759
1760         // Serialize patch:Set message to set property
1761 #ifdef HAVE_LV2_1_10_0
1762         lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Set);
1763         lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
1764         lv2_atom_forge_urid(forge, key);
1765         lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
1766 #else
1767         lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Set);
1768         lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
1769         lv2_atom_forge_urid(forge, key);
1770         lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
1771 #endif
1772
1773         forge_variant(forge, value);
1774
1775         // Write message to UI=>Plugin ring
1776         const LV2_Atom* const atom = (const LV2_Atom*)buf;
1777         write_from_ui(_patch_port_in_index,
1778                       _uri_map.urids.atom_eventTransfer,
1779                       lv2_atom_total_size(atom),
1780                       (const uint8_t*)atom);
1781 }
1782
1783 const ParameterDescriptor&
1784 LV2Plugin::get_property_descriptor(uint32_t id) const
1785 {
1786         PropertyDescriptors::const_iterator p = _property_descriptors.find(id);
1787         if (p != _property_descriptors.end()) {
1788                 return p->second;
1789         }
1790         return Plugin::get_property_descriptor(id);
1791 }
1792
1793 static void
1794 load_parameter_descriptor_units(LilvWorld* lworld, ParameterDescriptor& desc, const LilvNodes* units)
1795 {
1796         if (lilv_nodes_contains(units, _world.units_midiNote)) {
1797                 desc.unit = ParameterDescriptor::MIDI_NOTE;
1798         } else if (lilv_nodes_contains(units, _world.units_db)) {
1799                 desc.unit = ParameterDescriptor::DB;
1800         } else if (lilv_nodes_contains(units, _world.units_hz)) {
1801                 desc.unit = ParameterDescriptor::HZ;
1802         }
1803         if (lilv_nodes_size(units) > 0) {
1804                 const LilvNode* unit = lilv_nodes_get_first(units);
1805                 LilvNode* render = get_value(lworld, unit, _world.units_render);
1806                 if (render) {
1807                         desc.print_fmt = lilv_node_as_string(render);
1808                         replace_all (desc.print_fmt, "%f", "%.2f");
1809                         lilv_node_free(render);
1810                 }
1811         }
1812 }
1813
1814 static void
1815 load_parameter_descriptor(LV2World&            world,
1816                           ParameterDescriptor& desc,
1817                           Variant::Type        datatype,
1818                           const LilvNode*      subject)
1819 {
1820         LilvWorld* lworld  = _world.world;
1821         LilvNode*  label   = get_value(lworld, subject, _world.rdfs_label);
1822         LilvNode*  def     = get_value(lworld, subject, _world.lv2_default);
1823         LilvNode*  minimum = get_value(lworld, subject, _world.lv2_minimum);
1824         LilvNode*  maximum = get_value(lworld, subject, _world.lv2_maximum);
1825         LilvNodes* units   = lilv_world_find_nodes(lworld, subject, _world.units_unit, NULL);
1826         if (label) {
1827                 desc.label = lilv_node_as_string(label);
1828         }
1829         if (def) {
1830                 if (lilv_node_is_float(def)) {
1831                         desc.normal = lilv_node_as_float(def);
1832                 } else if (lilv_node_is_int(def)) {
1833                         desc.normal = lilv_node_as_int(def);
1834                 }
1835         }
1836         if (minimum) {
1837                 if (lilv_node_is_float(minimum)) {
1838                         desc.lower = lilv_node_as_float(minimum);
1839                 } else if (lilv_node_is_int(minimum)) {
1840                         desc.lower = lilv_node_as_int(minimum);
1841                 }
1842         }
1843         if (maximum) {
1844                 if (lilv_node_is_float(maximum)) {
1845                         desc.upper = lilv_node_as_float(maximum);
1846                 } else if (lilv_node_is_int(maximum)) {
1847                         desc.upper = lilv_node_as_int(maximum);
1848                 }
1849         }
1850         load_parameter_descriptor_units(lworld, desc, units);
1851         desc.datatype      = datatype;
1852         desc.toggled      |= datatype == Variant::BOOL;
1853         desc.integer_step |= datatype == Variant::INT || datatype == Variant::LONG;
1854         desc.update_steps();
1855
1856         lilv_nodes_free(units);
1857         lilv_node_free(label);
1858         lilv_node_free(def);
1859         lilv_node_free(minimum);
1860         lilv_node_free(maximum);
1861 }
1862
1863 void
1864 LV2Plugin::load_supported_properties(PropertyDescriptors& descs)
1865 {
1866         LilvWorld*       lworld     = _world.world;
1867         const LilvNode*  subject    = lilv_plugin_get_uri(_impl->plugin);
1868         LilvNodes*       properties = lilv_world_find_nodes(
1869                 lworld, subject, _world.patch_writable, NULL);
1870         LILV_FOREACH(nodes, p, properties) {
1871                 // Get label and range
1872                 const LilvNode* prop  = lilv_nodes_get(properties, p);
1873                 LilvNode*       range = get_value(lworld, prop, _world.rdfs_range);
1874                 if (!range) {
1875                         warning << string_compose(_("LV2: property <%1> has no range datatype, ignoring"),
1876                                                   lilv_node_as_uri(prop)) << endmsg;
1877                         continue;
1878                 }
1879
1880                 // Convert range to variant type (TODO: support for multiple range types)
1881                 Variant::Type datatype;
1882                 if (!uri_to_variant_type(lilv_node_as_uri(range), datatype)) {
1883                         error << string_compose(_("LV2: property <%1> has unsupported datatype <%1>"),
1884                                                 lilv_node_as_uri(prop), lilv_node_as_uri(range)) << endmsg;
1885                         continue;
1886                 }
1887
1888                 // Add description to result
1889                 ParameterDescriptor desc;
1890                 desc.key      = _uri_map.uri_to_id(lilv_node_as_uri(prop));
1891                 desc.datatype = datatype;
1892                 load_parameter_descriptor(_world, desc, datatype, prop);
1893                 descs.insert(std::make_pair(desc.key, desc));
1894
1895                 lilv_node_free(range);
1896         }
1897         lilv_nodes_free(properties);
1898 }
1899
1900 void
1901 LV2Plugin::announce_property_values()
1902 {
1903         if (_patch_port_in_index == (uint32_t)-1) {
1904                 return;
1905         }
1906
1907         // Set up forge to write to temporary buffer on the stack
1908         LV2_Atom_Forge*      forge = &_impl->ui_forge;
1909         LV2_Atom_Forge_Frame frame;
1910         uint8_t              buf[PATH_MAX];  // Ought to be enough for anyone...
1911
1912         lv2_atom_forge_set_buffer(forge, buf, sizeof(buf));
1913
1914         // Serialize patch:Get message with no subject (implicitly plugin instance)
1915 #ifdef HAVE_LV2_1_10_0
1916         lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Get);
1917 #else
1918         lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Get);
1919 #endif
1920
1921         // Write message to UI=>Plugin ring
1922         const LV2_Atom* const atom = (const LV2_Atom*)buf;
1923         write_from_ui(_patch_port_in_index,
1924                       _uri_map.urids.atom_eventTransfer,
1925                       lv2_atom_total_size(atom),
1926                       (const uint8_t*)atom);
1927 }
1928
1929 void
1930 LV2Plugin::enable_ui_emission()
1931 {
1932         if (!_to_ui) {
1933                 /* see note in LV2Plugin::write_from_ui() */
1934                 uint32_t bufsiz = 32768;
1935                 if (_atom_ev_buffers && _atom_ev_buffers[0]) {
1936                         bufsiz =  lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
1937                 }
1938                 size_t rbs = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
1939                 rbs = max((size_t) bufsiz * 8, rbs);
1940                 _to_ui = new RingBuffer<uint8_t>(rbs);
1941         }
1942 }
1943
1944 void
1945 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1946 {
1947         if (!_to_ui) {
1948                 return;
1949         }
1950
1951         uint32_t read_space = _to_ui->read_space();
1952         while (read_space > sizeof(UIMessage)) {
1953                 UIMessage msg;
1954                 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1955                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1956                         break;
1957                 }
1958                 vector<uint8_t> body(msg.size);
1959                 if (_to_ui->read(&body[0], msg.size) != msg.size) {
1960                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1961                         break;
1962                 }
1963
1964                 sink(controller, msg.index, msg.size, msg.protocol, &body[0]);
1965
1966                 read_space -= sizeof(msg) + msg.size;
1967         }
1968 }
1969
1970 int
1971 LV2Plugin::work(Worker& worker, uint32_t size, const void* data)
1972 {
1973         Glib::Threads::Mutex::Lock lm(_work_mutex);
1974         return _impl->work_iface->work(
1975                 _impl->instance->lv2_handle, work_respond, &worker, size, data);
1976 }
1977
1978 int
1979 LV2Plugin::work_response(uint32_t size, const void* data)
1980 {
1981         return _impl->work_iface->work_response(
1982                 _impl->instance->lv2_handle, size, data);
1983 }
1984
1985 void
1986 LV2Plugin::set_insert_id(PBD::ID id)
1987 {
1988         if (_insert_id == "0") {
1989                 _insert_id = id;
1990         } else if (_insert_id != id) {
1991                 lilv_state_free(_impl->state);
1992                 _impl->state = NULL;
1993                 _insert_id   = id;
1994         }
1995 }
1996
1997 void
1998 LV2Plugin::set_state_dir (const std::string& d)
1999 {
2000         _plugin_state_dir = d;
2001 }
2002
2003 int
2004 LV2Plugin::set_state(const XMLNode& node, int version)
2005 {
2006         XMLNodeList          nodes;
2007         XMLProperty const * prop;
2008         XMLNodeConstIterator iter;
2009         XMLNode*             child;
2010         const char*          sym;
2011         const char*          value;
2012         uint32_t             port_id;
2013         LocaleGuard          lg;
2014
2015         if (node.name() != state_node_name()) {
2016                 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
2017                 return -1;
2018         }
2019
2020 #ifndef NO_PLUGIN_STATE
2021
2022         if (version < 3000) {
2023                 nodes = node.children("port");
2024         } else {
2025                 nodes = node.children("Port");
2026         }
2027
2028         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
2029
2030                 child = *iter;
2031
2032                 if ((prop = child->property("symbol")) != 0) {
2033                         sym = prop->value().c_str();
2034                 } else {
2035                         warning << _("LV2: port has no symbol, ignored") << endmsg;
2036                         continue;
2037                 }
2038
2039                 map<string, uint32_t>::iterator i = _port_indices.find(sym);
2040
2041                 if (i != _port_indices.end()) {
2042                         port_id = i->second;
2043                 } else {
2044                         warning << _("LV2: port has unknown index, ignored") << endmsg;
2045                         continue;
2046                 }
2047
2048                 if ((prop = child->property("value")) != 0) {
2049                         value = prop->value().c_str();
2050                 } else {
2051                         warning << _("LV2: port has no value, ignored") << endmsg;
2052                         continue;
2053                 }
2054
2055                 set_parameter(port_id, atof(value));
2056         }
2057
2058         if ((prop = node.property("template-dir")) != 0) {
2059                 set_state_dir (prop->value ());
2060         }
2061
2062         _state_version = 0;
2063         if ((prop = node.property("state-dir")) != 0) {
2064                 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
2065                         error << string_compose(
2066                                 "LV2: failed to parse state version from \"%1\"",
2067                                 prop->value()) << endmsg;
2068                 }
2069
2070                 std::string state_file = Glib::build_filename(
2071                         plugin_dir(),
2072                         Glib::build_filename(prop->value(), "state.ttl"));
2073
2074                 LilvState* state = lilv_state_new_from_file(
2075                         _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
2076
2077                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
2078                 lilv_state_free(_impl->state);
2079                 _impl->state = state;
2080         }
2081
2082         if (!_plugin_state_dir.empty ()) {
2083                 // force save with session, next time (increment counter)
2084                 lilv_state_free (_impl->state);
2085                 _impl->state = NULL;
2086                 set_state_dir ("");
2087         }
2088
2089         latency_compute_run();
2090 #endif
2091
2092         return Plugin::set_state(node, version);
2093 }
2094
2095 int
2096 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
2097 {
2098         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
2099         if (!port) {
2100                 error << string_compose("LV2: get descriptor of non-existent port %1", which)
2101                       << endmsg;
2102                 return 1;
2103         }
2104
2105         LilvNodes* portunits;
2106         LilvNode *def, *min, *max;
2107         lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
2108         portunits = lilv_port_get_value(_impl->plugin, port, _world.units_unit);
2109
2110         LilvNode* steps   = lilv_port_get(_impl->plugin, port, _world.ext_rangeSteps);
2111
2112         // TODO: Once we can rely on lilv 0.18.0 being present,
2113         // load_parameter_descriptor() can be used for ports as well
2114         desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
2115         desc.toggled      = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
2116         desc.logarithmic  = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
2117         desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
2118         desc.label        = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
2119         desc.normal       = def ? lilv_node_as_float(def) : 0.0f;
2120         desc.lower        = min ? lilv_node_as_float(min) : 0.0f;
2121         desc.upper        = max ? lilv_node_as_float(max) : 1.0f;
2122         load_parameter_descriptor_units(_world.world, desc, portunits);
2123
2124         if (desc.sr_dependent) {
2125                 desc.lower *= _session.frame_rate ();
2126                 desc.upper *= _session.frame_rate ();
2127         }
2128
2129         desc.min_unbound  = false; // TODO: LV2 extension required
2130         desc.max_unbound  = false; // TODO: LV2 extension required
2131
2132         desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
2133         desc.scale_points = get_scale_points(which);
2134
2135         desc.update_steps();
2136
2137         if (steps) {
2138                 //override auto-calculated steps in update_steps()
2139                 float s = lilv_node_as_float (steps);
2140                 const float delta = desc.upper - desc.lower;
2141
2142                 desc.step = desc.smallstep = (delta / s);
2143                 desc.largestep = std::min ((delta / 5.0f), 10.f * desc.smallstep);
2144
2145                 if (desc.logarithmic) {
2146                         // TODO marry AutomationControl::internal_to_interface () with
2147                         // http://lv2plug.in/ns/ext/port-props/#rangeSteps
2148                         desc.smallstep = desc.smallstep / logf(s);
2149                         desc.step      = desc.step      / logf(s);
2150                         desc.largestep = desc.largestep / logf(s);
2151                 } else if (desc.integer_step) {
2152                         desc.smallstep = 1.0;
2153                         desc.step      = std::max(1.f, rintf (desc.step));
2154                         desc.largestep = std::max(1.f, rintf (desc.largestep));
2155                 }
2156                 DEBUG_TRACE(DEBUG::LV2, string_compose("parameter %1 small: %2, step: %3 largestep: %4\n",
2157                                         which, desc.smallstep, desc.step, desc.largestep));
2158         }
2159
2160
2161         lilv_node_free(def);
2162         lilv_node_free(min);
2163         lilv_node_free(max);
2164         lilv_node_free(steps);
2165         lilv_nodes_free(portunits);
2166
2167         return 0;
2168 }
2169
2170 Plugin::IOPortDescription
2171 LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const
2172 {
2173         PortFlags match = 0;
2174         switch (dt) {
2175                 case DataType::AUDIO:
2176                         match = PORT_AUDIO;
2177                         break;
2178                 case DataType::MIDI:
2179                         match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT
2180                         break;
2181                 default:
2182                         return Plugin::IOPortDescription ("?");
2183                         break;
2184         }
2185         if (input) {
2186                 match |= PORT_INPUT;
2187         } else {
2188                 match |= PORT_OUTPUT;
2189         }
2190
2191         uint32_t p = 0;
2192         uint32_t idx = UINT32_MAX;
2193
2194         uint32_t const num_ports = parameter_count();
2195         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2196                 PortFlags flags = _port_flags[port_index];
2197                 if ((flags & match) == match) {
2198                         if (p == id) {
2199                                 idx = port_index;
2200                         }
2201                         ++p;
2202                 }
2203         }
2204         if (idx == UINT32_MAX) {
2205                 return Plugin::IOPortDescription ("?");
2206         }
2207
2208         const LilvPort* pport = lilv_plugin_get_port_by_index (_impl->plugin, idx);
2209
2210         LilvNode* name = lilv_port_get_name(_impl->plugin, pport);
2211         Plugin::IOPortDescription iod (lilv_node_as_string (name));
2212         lilv_node_free(name);
2213
2214         /* get the port's pg:group */
2215         LilvNodes* groups = lilv_port_get_value (_impl->plugin, pport, _world.groups_group);
2216         if (lilv_nodes_size (groups) > 0) {
2217                 const LilvNode* group = lilv_nodes_get_first (groups);
2218                 LilvNodes* grouplabel = lilv_world_find_nodes (_world.world, group, _world.rdfs_label, NULL);
2219
2220                 /* get the name of the port-group */
2221                 if (lilv_nodes_size (grouplabel) > 0) {
2222                         const LilvNode* grpname = lilv_nodes_get_first (grouplabel);
2223                         iod.group_name = lilv_node_as_string (grpname);
2224                 }
2225                 lilv_nodes_free (grouplabel);
2226
2227                 /* get all port designations.
2228                  * we're interested in e.g. lv2:designation pg:right */
2229                 LilvNodes* designations = lilv_port_get_value (_impl->plugin, pport, _world.lv2_designation);
2230                 if (lilv_nodes_size (designations) > 0) {
2231                         /* get all pg:elements of the pg:group */
2232                         LilvNodes* group_childs = lilv_world_find_nodes (_world.world, group, _world.groups_element, NULL);
2233                         if (lilv_nodes_size (group_childs) > 0) {
2234                                 /* iterate over all port designations .. */
2235                                 LILV_FOREACH (nodes, i, designations) {
2236                                         const LilvNode* designation = lilv_nodes_get (designations, i);
2237                                         /* match the lv2:designation's element against the port-group's element */
2238                                         LILV_FOREACH (nodes, j, group_childs) {
2239                                                 const LilvNode* group_element = lilv_nodes_get (group_childs, j);
2240                                                 LilvNodes* elem = lilv_world_find_nodes (_world.world, group_element, _world.lv2_designation, designation);
2241                                                 /* found it. Now look up the index (channel-number) of the pg:Element */
2242                                                 if (lilv_nodes_size (elem) > 0) {
2243                                                         LilvNodes* idx = lilv_world_find_nodes (_world.world, lilv_nodes_get_first (elem), _world.lv2_index, NULL);
2244                                                         if (lilv_node_is_int (lilv_nodes_get_first (idx))) {
2245                                                                 iod.group_channel = lilv_node_as_int(lilv_nodes_get_first (idx));
2246                                                         }
2247                                                 }
2248                                         }
2249                                 }
2250                         }
2251                 }
2252                 lilv_nodes_free (groups);
2253                 lilv_nodes_free (designations);
2254         }
2255
2256         if (lilv_port_has_property(_impl->plugin, pport, _world.lv2_isSideChain)) {
2257                 iod.is_sidechain = true;
2258         }
2259         return iod;
2260 }
2261
2262 string
2263 LV2Plugin::describe_parameter(Evoral::Parameter which)
2264 {
2265         if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
2266
2267                 if (lilv_port_has_property(_impl->plugin,
2268                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
2269                         return X_("hidden");
2270                 }
2271
2272                 if (lilv_port_has_property(_impl->plugin,
2273                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
2274                         return X_("hidden");
2275                 }
2276
2277                 if (lilv_port_has_property(_impl->plugin,
2278                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
2279                         return X_("latency");
2280                 }
2281
2282                 LilvNode* name = lilv_port_get_name(_impl->plugin,
2283                                                     lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
2284                 string ret(lilv_node_as_string(name));
2285                 lilv_node_free(name);
2286                 return ret;
2287         } else {
2288                 return "??";
2289         }
2290 }
2291
2292 framecnt_t
2293 LV2Plugin::max_latency () const
2294 {
2295         return _max_latency;
2296 }
2297
2298 framecnt_t
2299 LV2Plugin::signal_latency() const
2300 {
2301         if (_latency_control_port) {
2302                 return (framecnt_t)floor(*_latency_control_port);
2303         } else {
2304                 return 0;
2305         }
2306 }
2307
2308 set<Evoral::Parameter>
2309 LV2Plugin::automatable() const
2310 {
2311         set<Evoral::Parameter> ret;
2312
2313         for (uint32_t i = 0; i < parameter_count(); ++i) {
2314                 if (parameter_is_input(i) && parameter_is_control(i) && !(_port_flags[i] & PORT_NOAUTO)) {
2315                         ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
2316                 }
2317         }
2318
2319         for (PropertyDescriptors::const_iterator p = _property_descriptors.begin();
2320              p != _property_descriptors.end();
2321              ++p) {
2322                 ret.insert(ret.end(), Evoral::Parameter(PluginPropertyAutomation, 0, p->first));
2323         }
2324         return ret;
2325 }
2326
2327 void
2328 LV2Plugin::set_automation_control (uint32_t i, boost::shared_ptr<AutomationControl> c)
2329 {
2330         if ((_port_flags[i] & (PORT_CTRLED | PORT_CTRLER))) {
2331                 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Ctrl Port %1\n", i));
2332                 _ctrl_map [i] = AutomationCtrlPtr (new AutomationCtrl(c));
2333         }
2334 }
2335
2336 LV2Plugin::AutomationCtrlPtr
2337 LV2Plugin::get_automation_control (uint32_t i)
2338 {
2339         if (_ctrl_map.find (i) == _ctrl_map.end()) {
2340                 return AutomationCtrlPtr ();
2341         }
2342         return _ctrl_map[i];
2343 }
2344
2345 void
2346 LV2Plugin::activate()
2347 {
2348         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
2349
2350         if (!_was_activated) {
2351                 lilv_instance_activate(_impl->instance);
2352                 _was_activated = true;
2353         }
2354 }
2355
2356 void
2357 LV2Plugin::deactivate()
2358 {
2359         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
2360
2361         if (_was_activated) {
2362                 lilv_instance_deactivate(_impl->instance);
2363                 _was_activated = false;
2364         }
2365 }
2366
2367 void
2368 LV2Plugin::cleanup()
2369 {
2370         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
2371
2372         deactivate();
2373         lilv_instance_free(_impl->instance);
2374         _impl->instance = NULL;
2375 }
2376
2377 void
2378 LV2Plugin::allocate_atom_event_buffers()
2379 {
2380         /* reserve local scratch buffers for ATOM event-queues */
2381         const LilvPlugin* p = _impl->plugin;
2382
2383         /* count non-MIDI atom event-ports
2384          * TODO: nicely ask drobilla to make a lilv_ call for that
2385          */
2386         int count_atom_out = 0;
2387         int count_atom_in = 0;
2388         int minimumSize = 32768; // TODO use a per-port minimum-size
2389         for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2390                 const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
2391                 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2392                         LilvNodes* buffer_types = lilv_port_get_value(
2393                                 p, port, _world.atom_bufferType);
2394                         LilvNodes* atom_supports = lilv_port_get_value(
2395                                 p, port, _world.atom_supports);
2396
2397                         if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
2398                                 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2399                                         count_atom_in++;
2400                                 }
2401                                 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2402                                         count_atom_out++;
2403                                 }
2404                                 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
2405                                 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
2406                                 if (min_size && lilv_node_is_int(min_size)) {
2407                                         minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
2408                                 }
2409                                 lilv_nodes_free(min_size_v);
2410                         }
2411                         lilv_nodes_free(buffer_types);
2412                         lilv_nodes_free(atom_supports);
2413                 }
2414         }
2415
2416         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
2417                                 name(), count_atom_in, count_atom_out));
2418
2419         const int total_atom_buffers = (count_atom_in + count_atom_out);
2420         if (_atom_ev_buffers || total_atom_buffers == 0) {
2421                 return;
2422         }
2423
2424         DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize));
2425         _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
2426         for (int i = 0; i < total_atom_buffers; ++i ) {
2427                 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
2428                                 _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence);
2429         }
2430         _atom_ev_buffers[total_atom_buffers] = 0;
2431         return;
2432 }
2433
2434 /** Write an ardour position/time/tempo/meter as an LV2 event.
2435  * @return true on success.
2436  */
2437 static bool
2438 write_position(LV2_Atom_Forge*     forge,
2439                LV2_Evbuf*          buf,
2440                const TempoMetric&  t,
2441                Timecode::BBT_Time& bbt,
2442                double              speed,
2443                double              bpm,
2444                framepos_t          position,
2445                framecnt_t          offset)
2446 {
2447         const URIMap::URIDs& urids = URIMap::instance().urids;
2448
2449         uint8_t pos_buf[256];
2450         lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
2451         LV2_Atom_Forge_Frame frame;
2452 #ifdef HAVE_LV2_1_10_0
2453         lv2_atom_forge_object(forge, &frame, 0, urids.time_Position);
2454         lv2_atom_forge_key(forge, urids.time_frame);
2455         lv2_atom_forge_long(forge, position);
2456         lv2_atom_forge_key(forge, urids.time_speed);
2457         lv2_atom_forge_float(forge, speed);
2458         lv2_atom_forge_key(forge, urids.time_barBeat);
2459         lv2_atom_forge_float(forge, bbt.beats - 1 +
2460                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2461         lv2_atom_forge_key(forge, urids.time_bar);
2462         lv2_atom_forge_long(forge, bbt.bars - 1);
2463         lv2_atom_forge_key(forge, urids.time_beatUnit);
2464         lv2_atom_forge_int(forge, t.meter().note_divisor());
2465         lv2_atom_forge_key(forge, urids.time_beatsPerBar);
2466         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2467         lv2_atom_forge_key(forge, urids.time_beatsPerMinute);
2468         lv2_atom_forge_float(forge, bpm);
2469 #else
2470         lv2_atom_forge_blank(forge, &frame, 1, urids.time_Position);
2471         lv2_atom_forge_property_head(forge, urids.time_frame, 0);
2472         lv2_atom_forge_long(forge, position);
2473         lv2_atom_forge_property_head(forge, urids.time_speed, 0);
2474         lv2_atom_forge_float(forge, speed);
2475         lv2_atom_forge_property_head(forge, urids.time_barBeat, 0);
2476         lv2_atom_forge_float(forge, bbt.beats - 1 +
2477                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
2478         lv2_atom_forge_property_head(forge, urids.time_bar, 0);
2479         lv2_atom_forge_long(forge, bbt.bars - 1);
2480         lv2_atom_forge_property_head(forge, urids.time_beatUnit, 0);
2481         lv2_atom_forge_int(forge, t.meter().note_divisor());
2482         lv2_atom_forge_property_head(forge, urids.time_beatsPerBar, 0);
2483         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
2484         lv2_atom_forge_property_head(forge, urids.time_beatsPerMinute, 0);
2485         lv2_atom_forge_float(forge, bpm);
2486 #endif
2487
2488         LV2_Evbuf_Iterator    end  = lv2_evbuf_end(buf);
2489         const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
2490         return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
2491                                (const uint8_t*)(atom + 1));
2492 }
2493
2494 int
2495 LV2Plugin::connect_and_run(BufferSet& bufs,
2496                 framepos_t start, framepos_t end, double speed,
2497                 ChanMapping in_map, ChanMapping out_map,
2498                 pframes_t nframes, framecnt_t offset)
2499 {
2500         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
2501         Plugin::connect_and_run(bufs, start, end, speed, in_map, out_map, nframes, offset);
2502
2503         cycles_t then = get_cycles();
2504
2505         TempoMap&               tmap     = _session.tempo_map();
2506         Metrics::const_iterator metric_i = tmap.metrics_end();
2507         TempoMetric             tmetric  = tmap.metric_at(start, &metric_i);
2508
2509         if (_freewheel_control_port) {
2510                 *_freewheel_control_port = _session.engine().freewheeling() ? 1.f : 0.f;
2511         }
2512
2513         if (_bpm_control_port) {
2514                 *_bpm_control_port = tmap.tempo_at_frame (start).note_types_per_minute();
2515         }
2516
2517 #ifdef LV2_EXTENDED
2518         if (_can_write_automation && start != _next_cycle_start) {
2519                 // add guard-points after locating
2520                 for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2521                         i->second->guard = true;
2522                 }
2523         }
2524 #endif
2525
2526         ChanCount bufs_count;
2527         bufs_count.set(DataType::AUDIO, 1);
2528         bufs_count.set(DataType::MIDI, 1);
2529         BufferSet& silent_bufs  = _session.get_silent_buffers(bufs_count);
2530         BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
2531         uint32_t const num_ports = parameter_count();
2532         uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
2533
2534         uint32_t audio_in_index  = 0;
2535         uint32_t audio_out_index = 0;
2536         uint32_t midi_in_index   = 0;
2537         uint32_t midi_out_index  = 0;
2538         uint32_t atom_port_index = 0;
2539         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2540                 void*     buf   = NULL;
2541                 uint32_t  index = nil_index;
2542                 PortFlags flags = _port_flags[port_index];
2543                 bool      valid = false;
2544                 if (flags & PORT_AUDIO) {
2545                         if (flags & PORT_INPUT) {
2546                                 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
2547                                 buf = (valid)
2548                                         ? bufs.get_audio(index).data(offset)
2549                                         : silent_bufs.get_audio(0).data(offset);
2550                         } else {
2551                                 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
2552                                 buf = (valid)
2553                                         ? bufs.get_audio(index).data(offset)
2554                                         : scratch_bufs.get_audio(0).data(offset);
2555                         }
2556                 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
2557                         /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
2558                            be necessary, but the mapping is illegal in some cases.  Ideally
2559                            that should be fixed, but this is easier...
2560                         */
2561                         if (flags & PORT_MIDI) {
2562                                 if (flags & PORT_INPUT) {
2563                                         index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
2564                                 } else {
2565                                         index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
2566                                 }
2567                                 if (valid && bufs.count().n_midi() > index) {
2568                                         /* Note, ensure_lv2_bufsize() is not RT safe!
2569                                          * However free()/alloc() is only called if a
2570                                          * plugin requires a rsz:minimumSize buffersize
2571                                          * and the existing buffer if smaller.
2572                                          */
2573                                         bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
2574                                         _ev_buffers[port_index] = bufs.get_lv2_midi(
2575                                                 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
2576                                 }
2577                         } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
2578                                 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
2579                                 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
2580                                 valid                   = true;
2581                         }
2582
2583                         if (valid && (flags & PORT_INPUT)) {
2584                                 if ((flags & PORT_POSITION)) {
2585                                         Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2586                                         double bpm = tmap.tempo_at_frame (start).note_types_per_minute();
2587                                         double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
2588                                                        + (bbt.beats - 1)
2589                                                        + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2590                                         beatpos *= tmetric.meter().note_divisor() / 4.0;
2591                                         if (start != _next_cycle_start ||
2592                                                         speed != _next_cycle_speed ||
2593                                                         rint (1000 * beatpos) != rint(1000 * _next_cycle_beat) ||
2594                                                         bpm != _current_bpm) {
2595                                                 // Transport or Tempo has changed, write position at cycle start
2596                                                 write_position(&_impl->forge, _ev_buffers[port_index],
2597                                                                 tmetric, bbt, speed, bpm, start, 0);
2598                                         }
2599                                 }
2600
2601                                 // Get MIDI iterator range (empty range if no MIDI)
2602                                 MidiBuffer::iterator m = (index != nil_index)
2603                                         ? bufs.get_midi(index).begin()
2604                                         : silent_bufs.get_midi(0).end();
2605                                 MidiBuffer::iterator m_end = (index != nil_index)
2606                                         ? bufs.get_midi(index).end()
2607                                         : m;
2608
2609                                 // Now merge MIDI and any transport events into the buffer
2610                                 const uint32_t     type = _uri_map.urids.midi_MidiEvent;
2611                                 const framepos_t   tend = end;
2612                                 ++metric_i;
2613                                 while (m != m_end || (metric_i != tmap.metrics_end() &&
2614                                                       (*metric_i)->frame() < tend)) {
2615                                         MetricSection* metric = (metric_i != tmap.metrics_end())
2616                                                 ? *metric_i : NULL;
2617                                         if (m != m_end && (!metric || metric->frame() > (*m).time())) {
2618                                                 const Evoral::Event<framepos_t> ev(*m, false);
2619                                                 if (ev.time() < nframes) {
2620                                                         LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
2621                                                         lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
2622                                                 }
2623                                                 ++m;
2624                                         } else {
2625                                                 tmetric.set_metric(metric);
2626                                                 Timecode::BBT_Time bbt;
2627                                                 bbt = tmap.bbt_at_frame (metric->frame());
2628                                                 double bpm = tmap.tempo_at_frame (start/*XXX*/).note_types_per_minute();
2629                                                 write_position(&_impl->forge, _ev_buffers[port_index],
2630                                                                tmetric, bbt, speed, bpm,
2631                                                                metric->frame(),
2632                                                                metric->frame() - start);
2633                                                 ++metric_i;
2634                                         }
2635                                 }
2636                         } else if (!valid) {
2637                                 // Nothing we understand or care about, connect to scratch
2638                                 // see note for midi-buffer size above
2639                                 scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT),
2640                                                 0, _port_minimumSize[port_index]);
2641                                 _ev_buffers[port_index] = scratch_bufs.get_lv2_midi(
2642                                         (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
2643                         }
2644
2645                         buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
2646                 } else {
2647                         continue;  // Control port, leave buffer alone
2648                 }
2649                 lilv_instance_connect_port(_impl->instance, port_index, buf);
2650         }
2651
2652         // Read messages from UI and push into appropriate buffers
2653         if (_from_ui) {
2654                 uint32_t read_space = _from_ui->read_space();
2655                 while (read_space > sizeof(UIMessage)) {
2656                         UIMessage msg;
2657                         if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
2658                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2659                                 break;
2660                         }
2661                         vector<uint8_t> body(msg.size);
2662                         if (_from_ui->read(&body[0], msg.size) != msg.size) {
2663                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
2664                                 break;
2665                         }
2666                         if (msg.protocol == URIMap::instance().urids.atom_eventTransfer) {
2667                                 LV2_Evbuf*            buf  = _ev_buffers[msg.index];
2668                                 LV2_Evbuf_Iterator    i    = lv2_evbuf_end(buf);
2669                                 const LV2_Atom* const atom = (const LV2_Atom*)&body[0];
2670                                 if (!lv2_evbuf_write(&i, nframes - 1, 0, atom->type, atom->size,
2671                                                 (const uint8_t*)(atom + 1))) {
2672                                         error << "Failed to write data to LV2 event buffer\n";
2673                                 }
2674                         } else {
2675                                 error << "Received unknown message type from UI" << endmsg;
2676                         }
2677                         read_space -= sizeof(UIMessage) + msg.size;
2678                 }
2679         }
2680
2681         run(nframes);
2682
2683         midi_out_index = 0;
2684         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
2685                 PortFlags flags = _port_flags[port_index];
2686                 bool      valid = false;
2687
2688                 /* TODO ask drobilla about comment
2689                  * "Make Ardour event buffers generic so plugins can communicate"
2690                  * in libs/ardour/buffer_set.cc:310
2691                  *
2692                  * ideally the user could choose which of the following two modes
2693                  * to use (e.g. instrument/effect chains  MIDI OUT vs MIDI TRHU).
2694                  *
2695                  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
2696                  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
2697                  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
2698                  *                            for quite a while at least ;)
2699                  */
2700                 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
2701                 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
2702                         const uint32_t buf_index = out_map.get(
2703                                 DataType::MIDI, midi_out_index++, &valid);
2704                         if (valid) {
2705                                 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
2706                         }
2707                 }
2708                 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
2709                 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2710                         const uint32_t buf_index = out_map.get(
2711                                 DataType::MIDI, midi_out_index++, &valid);
2712                         if (valid) {
2713                                 bufs.flush_lv2_midi(true, buf_index);
2714                         }
2715                 }
2716
2717                 // Write messages to UI
2718                 if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) &&
2719                     (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
2720                         LV2_Evbuf* buf = _ev_buffers[port_index];
2721                         for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
2722                              lv2_evbuf_is_valid(i);
2723                              i = lv2_evbuf_next(i)) {
2724                                 uint32_t frames, subframes, type, size;
2725                                 uint8_t* data;
2726                                 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
2727
2728 #ifdef LV2_EXTENDED
2729                                 // Intercept Automation Write Events
2730                                 if ((flags & PORT_AUTOCTRL)) {
2731                                         LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2732                                         if (atom->type == _uri_map.urids.atom_Blank ||
2733                                                         atom->type == _uri_map.urids.atom_Object) {
2734                                                 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2735                                                 if (obj->body.otype == _uri_map.urids.auto_event) {
2736                                                         // only if transport_rolling ??
2737                                                         const LV2_Atom* parameter = NULL;
2738                                                         const LV2_Atom* value    = NULL;
2739                                                         lv2_atom_object_get(obj,
2740                                                                             _uri_map.urids.auto_parameter, &parameter,
2741                                                                             _uri_map.urids.auto_value,     &value,
2742                                                                             0);
2743                                                         if (parameter && value) {
2744                                                                 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2745                                                                 const float v = ((const LV2_Atom_Float*)value)->body;
2746                                                                 // -> add automation event..
2747                                                                 DEBUG_TRACE(DEBUG::LV2Automate,
2748                                                                                 string_compose ("Event p: %1 t: %2 v: %3\n", p, frames, v));
2749                                                                 AutomationCtrlPtr c = get_automation_control (p);
2750                                                                 if (c &&
2751                                                                      (c->ac->automation_state() == Touch || c->ac->automation_state() == Write)
2752                                                                    ) {
2753                                                                         framepos_t when = std::max ((framepos_t) 0, start + frames - _current_latency);
2754                                                                         assert (start + frames - _current_latency >= 0);
2755                                                                         if (c->guard) {
2756                                                                                 c->guard = false;
2757                                                                                 c->ac->list()->add (when, v, true, true);
2758                                                                         } else {
2759                                                                                 c->ac->set_double (v, when, true);
2760                                                                         }
2761                                                                 }
2762                                                         }
2763                                                 }
2764                                                 else if (obj->body.otype == _uri_map.urids.auto_setup) {
2765                                                         // TODO optional arguments, for now we assume the plugin
2766                                                         // writes automation for its own inputs
2767                                                         // -> put them in "touch" mode (preferably "exclusive plugin touch(TM)"
2768                                                         for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2769                                                                 if (_port_flags[i->first] & PORT_CTRLED) {
2770                                                                         DEBUG_TRACE(DEBUG::LV2Automate,
2771                                                                                 string_compose ("Setup p: %1\n", i->first));
2772                                                                         i->second->ac->set_automation_state (Touch);
2773                                                                 }
2774                                                         }
2775                                                 }
2776                                                 else if (obj->body.otype == _uri_map.urids.auto_finalize) {
2777                                                         // set [touched] parameters to "play" ??
2778                                                         // allow plugin to change its mode (from analyze to apply)
2779                                                         const LV2_Atom* parameter = NULL;
2780                                                         const LV2_Atom* value    = NULL;
2781                                                         lv2_atom_object_get(obj,
2782                                                                             _uri_map.urids.auto_parameter, &parameter,
2783                                                                             _uri_map.urids.auto_value,     &value,
2784                                                                             0);
2785                                                         if (parameter && value) {
2786                                                                 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2787                                                                 const float v = ((const LV2_Atom_Float*)value)->body;
2788                                                                 AutomationCtrlPtr c = get_automation_control (p);
2789                                                                 DEBUG_TRACE(DEBUG::LV2Automate,
2790                                                                                 string_compose ("Finalize p: %1 v: %2\n", p, v));
2791                                                                 if (c && _port_flags[p] & PORT_CTRLER) {
2792                                                                         c->ac->set_value(v, Controllable::NoGroup);
2793                                                                 }
2794                                                         } else {
2795                                                                 DEBUG_TRACE(DEBUG::LV2Automate, "Finalize\n");
2796                                                         }
2797                                                         for (AutomationCtrlMap::iterator i = _ctrl_map.begin(); i != _ctrl_map.end(); ++i) {
2798                                                                 // guard will be false if an event was written
2799                                                                 if ((_port_flags[i->first] & PORT_CTRLED) && !i->second->guard) {
2800                                                                         DEBUG_TRACE(DEBUG::LV2Automate,
2801                                                                                 string_compose ("Thin p: %1\n", i->first));
2802                                                                         i->second->ac->alist ()->thin (20);
2803                                                                 }
2804                                                         }
2805                                                 }
2806                                                 else if (obj->body.otype == _uri_map.urids.auto_start) {
2807                                                         const LV2_Atom* parameter = NULL;
2808                                                         lv2_atom_object_get(obj,
2809                                                                             _uri_map.urids.auto_parameter, &parameter,
2810                                                                             0);
2811                                                         if (parameter) {
2812                                                                 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2813                                                                 AutomationCtrlPtr c = get_automation_control (p);
2814                                                                 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("Start Touch p: %1\n", p));
2815                                                                 if (c) {
2816                                                                         c->ac->start_touch (std::max ((framepos_t)0, start - _current_latency));
2817                                                                         c->guard = true;
2818                                                                 }
2819                                                         }
2820                                                 }
2821                                                 else if (obj->body.otype == _uri_map.urids.auto_end) {
2822                                                         const LV2_Atom* parameter = NULL;
2823                                                         lv2_atom_object_get(obj,
2824                                                                             _uri_map.urids.auto_parameter, &parameter,
2825                                                                             0);
2826                                                         if (parameter) {
2827                                                                 const uint32_t p = ((const LV2_Atom_Int*)parameter)->body;
2828                                                                 AutomationCtrlPtr c = get_automation_control (p);
2829                                                                 DEBUG_TRACE(DEBUG::LV2Automate, string_compose ("End Touch p: %1\n", p));
2830                                                                 if (c) {
2831                                                                         c->ac->stop_touch (true, std::max ((framepos_t)0, start - _current_latency));
2832                                                                 }
2833                                                         }
2834                                                 }
2835                                         }
2836                                 }
2837 #endif
2838                                 // Intercept state dirty message
2839                                 if (_has_state_interface /* && (flags & PORT_DIRTYMSG)*/) {
2840                                         LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2841                                         if (atom->type == _uri_map.urids.atom_Blank ||
2842                                             atom->type == _uri_map.urids.atom_Object) {
2843                                                 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2844                                                 if (obj->body.otype == _uri_map.urids.state_StateChanged) {
2845                                                         _session.set_dirty ();
2846                                                 }
2847                                         }
2848                                 }
2849
2850                                 // Intercept patch change messages to emit PropertyChanged signal
2851                                 if ((flags & PORT_PATCHMSG)) {
2852                                         LV2_Atom* atom = (LV2_Atom*)(data - sizeof(LV2_Atom));
2853                                         if (atom->type == _uri_map.urids.atom_Blank ||
2854                                             atom->type == _uri_map.urids.atom_Object) {
2855                                                 LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
2856                                                 if (obj->body.otype == _uri_map.urids.patch_Set) {
2857                                                         const LV2_Atom* property = NULL;
2858                                                         const LV2_Atom* value    = NULL;
2859                                                         lv2_atom_object_get(obj,
2860                                                                             _uri_map.urids.patch_property, &property,
2861                                                                             _uri_map.urids.patch_value,    &value,
2862                                                                             0);
2863
2864                                                         if (property && value &&
2865                                                             property->type == _uri_map.urids.atom_URID &&
2866                                                             value->type    == _uri_map.urids.atom_Path) {
2867                                                                 const uint32_t prop_id = ((const LV2_Atom_URID*)property)->body;
2868                                                                 const char*    path    = (const char*)LV2_ATOM_BODY_CONST(value);
2869
2870                                                                 // Emit PropertyChanged signal for UI
2871                                                                 // TODO: This should emit the control's Changed signal
2872                                                                 PropertyChanged(prop_id, Variant(Variant::PATH, path));
2873                                                         } else {
2874                                                                 std::cerr << "warning: patch:Set for unknown property" << std::endl;
2875                                                         }
2876                                                 }
2877                                         }
2878                                 }
2879
2880                                 if (!_to_ui) continue;
2881                                 write_to_ui(port_index, URIMap::instance().urids.atom_eventTransfer,
2882                                             size + sizeof(LV2_Atom),
2883                                             data - sizeof(LV2_Atom));
2884                         }
2885                 }
2886         }
2887
2888         cycles_t now = get_cycles();
2889         set_cycles((uint32_t)(now - then));
2890
2891         // Update expected transport information for next cycle so we can detect changes
2892         _next_cycle_speed = speed;
2893         _next_cycle_start = end;
2894
2895         {
2896                 /* keep track of lv2:timePosition like plugins can do.
2897                  * Note: for no-midi plugins, we only ever send information at cycle-start,
2898                  * so it needs to be realative to that.
2899                  */
2900                 TempoMetric t = tmap.metric_at(start);
2901                 _current_bpm = tmap.tempo_at_frame (start).note_types_per_minute();
2902                 Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
2903                 double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
2904                                + (bbt.beats - 1)
2905                                + (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
2906                 beatpos *= tmetric.meter().note_divisor() / 4.0;
2907                 _next_cycle_beat = beatpos + nframes * speed * _current_bpm / (60.f * _session.frame_rate());
2908         }
2909
2910         if (_latency_control_port) {
2911                 framecnt_t new_latency = signal_latency ();
2912                 _current_latency = new_latency;
2913         }
2914         return 0;
2915 }
2916
2917 bool
2918 LV2Plugin::parameter_is_control(uint32_t param) const
2919 {
2920         assert(param < _port_flags.size());
2921         return _port_flags[param] & PORT_CONTROL;
2922 }
2923
2924 bool
2925 LV2Plugin::parameter_is_audio(uint32_t param) const
2926 {
2927         assert(param < _port_flags.size());
2928         return _port_flags[param] & PORT_AUDIO;
2929 }
2930
2931 bool
2932 LV2Plugin::parameter_is_event(uint32_t param) const
2933 {
2934         assert(param < _port_flags.size());
2935         return _port_flags[param] & PORT_EVENT;
2936 }
2937
2938 bool
2939 LV2Plugin::parameter_is_output(uint32_t param) const
2940 {
2941         assert(param < _port_flags.size());
2942         return _port_flags[param] & PORT_OUTPUT;
2943 }
2944
2945 bool
2946 LV2Plugin::parameter_is_input(uint32_t param) const
2947 {
2948         assert(param < _port_flags.size());
2949         return _port_flags[param] & PORT_INPUT;
2950 }
2951
2952 uint32_t
2953 LV2Plugin::designated_bypass_port ()
2954 {
2955         const LilvPort* port = NULL;
2956         LilvNode* designation = lilv_new_uri (_world.world, LV2_CORE_PREFIX "enabled");
2957         port = lilv_plugin_get_port_by_designation (
2958                         _impl->plugin, _world.lv2_InputPort, designation);
2959         lilv_node_free(designation);
2960         if (port) {
2961                 return lilv_port_get_index (_impl->plugin, port);
2962         }
2963 #ifdef LV2_EXTENDED
2964         /* deprecated on 2016-Sep-18 in favor of lv2:enabled */
2965         designation = lilv_new_uri (_world.world, LV2_PROCESSING_URI__enable);
2966         port = lilv_plugin_get_port_by_designation (
2967                         _impl->plugin, _world.lv2_InputPort, designation);
2968         lilv_node_free(designation);
2969         if (port) {
2970                 return lilv_port_get_index (_impl->plugin, port);
2971         }
2972 #endif
2973         return UINT32_MAX;
2974 }
2975
2976 void
2977 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
2978 {
2979         if (buf && len) {
2980                 if (param < parameter_count()) {
2981                         snprintf(buf, len, "%.3f", get_parameter(param));
2982                 } else {
2983                         strcat(buf, "0");
2984                 }
2985         }
2986 }
2987
2988 boost::shared_ptr<ScalePoints>
2989 LV2Plugin::get_scale_points(uint32_t port_index) const
2990 {
2991         const LilvPort*  port   = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
2992         LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
2993
2994         boost::shared_ptr<ScalePoints> ret;
2995         if (!points) {
2996                 return ret;
2997         }
2998
2999         ret = boost::shared_ptr<ScalePoints>(new ScalePoints());
3000
3001         LILV_FOREACH(scale_points, i, points) {
3002                 const LilvScalePoint* p     = lilv_scale_points_get(points, i);
3003                 const LilvNode*       label = lilv_scale_point_get_label(p);
3004                 const LilvNode*       value = lilv_scale_point_get_value(p);
3005                 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
3006                         ret->insert(make_pair(lilv_node_as_string(label),
3007                                               lilv_node_as_float(value)));
3008                 }
3009         }
3010
3011         lilv_scale_points_free(points);
3012         return ret;
3013 }
3014
3015 void
3016 LV2Plugin::run(pframes_t nframes, bool sync_work)
3017 {
3018         uint32_t const N = parameter_count();
3019         for (uint32_t i = 0; i < N; ++i) {
3020                 if (parameter_is_control(i) && parameter_is_input(i)) {
3021                         _control_data[i] = _shadow_data[i];
3022                 }
3023         }
3024
3025         if (_worker) {
3026                 // Execute work synchronously if we're freewheeling (export)
3027                 _worker->set_synchronous(sync_work || session().engine().freewheeling());
3028         }
3029
3030         // Run the plugin for this cycle
3031         lilv_instance_run(_impl->instance, nframes);
3032
3033         // Emit any queued worker responses (calls a plugin callback)
3034         if (_state_worker) {
3035                 _state_worker->emit_responses();
3036         }
3037         if (_worker) {
3038                 _worker->emit_responses();
3039         }
3040
3041         // Notify the plugin that a work run cycle is complete
3042         if (_impl->work_iface) {
3043                 if (_impl->work_iface->end_run) {
3044                         _impl->work_iface->end_run(_impl->instance->lv2_handle);
3045                 }
3046         }
3047 }
3048
3049 void
3050 LV2Plugin::latency_compute_run()
3051 {
3052         if (!_latency_control_port) {
3053                 return;
3054         }
3055
3056         // Run the plugin so that it can set its latency parameter
3057
3058         bool was_activated = _was_activated;
3059         activate();
3060
3061         uint32_t port_index = 0;
3062         uint32_t in_index   = 0;
3063         uint32_t out_index  = 0;
3064
3065         // this is done in the main thread. non realtime.
3066         const framecnt_t bufsize = _engine.samples_per_cycle();
3067         float            *buffer = (float*) malloc(_engine.samples_per_cycle() * sizeof(float));
3068
3069         memset(buffer, 0, sizeof(float) * bufsize);
3070
3071         // FIXME: Ensure plugins can handle in-place processing
3072
3073         port_index = 0;
3074
3075         while (port_index < parameter_count()) {
3076                 if (parameter_is_audio(port_index)) {
3077                         if (parameter_is_input(port_index)) {
3078                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3079                                 in_index++;
3080                         } else if (parameter_is_output(port_index)) {
3081                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
3082                                 out_index++;
3083                         }
3084                 }
3085                 port_index++;
3086         }
3087
3088         run(bufsize, true);
3089         deactivate();
3090         if (was_activated) {
3091                 activate();
3092         }
3093         free(buffer);
3094 }
3095
3096 const LilvPort*
3097 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
3098 {
3099         const LilvPort* port = NULL;
3100         LilvNode* designation = lilv_new_uri(_world.world, uri);
3101         port = lilv_plugin_get_port_by_designation(
3102                 plugin, _world.lv2_InputPort, designation);
3103         lilv_node_free(designation);
3104         if (port) {
3105                 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
3106         }
3107         return port;
3108 }
3109
3110 static bool lv2_filter (const string& str, void* /*arg*/)
3111 {
3112         /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
3113
3114         return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
3115 }
3116
3117
3118 LV2World::LV2World()
3119         : world(lilv_world_new())
3120         , _bundle_checked(false)
3121 {
3122         atom_AtomPort      = lilv_new_uri(world, LV2_ATOM__AtomPort);
3123         atom_Chunk         = lilv_new_uri(world, LV2_ATOM__Chunk);
3124         atom_Sequence      = lilv_new_uri(world, LV2_ATOM__Sequence);
3125         atom_bufferType    = lilv_new_uri(world, LV2_ATOM__bufferType);
3126         atom_supports      = lilv_new_uri(world, LV2_ATOM__supports);
3127         atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
3128         ev_EventPort       = lilv_new_uri(world, LILV_URI_EVENT_PORT);
3129         ext_logarithmic    = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
3130         ext_notOnGUI       = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
3131         ext_expensive      = lilv_new_uri(world, LV2_PORT_PROPS__expensive);
3132         ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
3133         ext_notAutomatic   = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
3134         ext_rangeSteps     = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
3135         groups_group       = lilv_new_uri(world, LV2_PORT_GROUPS__group);
3136         groups_element     = lilv_new_uri(world, LV2_PORT_GROUPS__element);
3137         lv2_AudioPort      = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
3138         lv2_ControlPort    = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
3139         lv2_InputPort      = lilv_new_uri(world, LILV_URI_INPUT_PORT);
3140         lv2_OutputPort     = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
3141         lv2_inPlaceBroken  = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
3142         lv2_isSideChain    = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
3143         lv2_index          = lilv_new_uri(world, LV2_CORE__index);
3144         lv2_integer        = lilv_new_uri(world, LV2_CORE__integer);
3145         lv2_default        = lilv_new_uri(world, LV2_CORE__default);
3146         lv2_minimum        = lilv_new_uri(world, LV2_CORE__minimum);
3147         lv2_maximum        = lilv_new_uri(world, LV2_CORE__maximum);
3148         lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
3149         lv2_sampleRate     = lilv_new_uri(world, LV2_CORE__sampleRate);
3150         lv2_toggled        = lilv_new_uri(world, LV2_CORE__toggled);
3151         lv2_designation    = lilv_new_uri(world, LV2_CORE__designation);
3152         lv2_enumeration    = lilv_new_uri(world, LV2_CORE__enumeration);
3153         lv2_freewheeling   = lilv_new_uri(world, LV2_CORE__freeWheeling);
3154         midi_MidiEvent     = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
3155         rdfs_comment       = lilv_new_uri(world, LILV_NS_RDFS "comment");
3156         rdfs_label         = lilv_new_uri(world, LILV_NS_RDFS "label");
3157         rdfs_range         = lilv_new_uri(world, LILV_NS_RDFS "range");
3158         rsz_minimumSize    = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
3159         time_Position      = lilv_new_uri(world, LV2_TIME__Position);
3160         ui_GtkUI           = lilv_new_uri(world, LV2_UI__GtkUI);
3161         ui_external        = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
3162         ui_externalkx      = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");
3163         units_unit         = lilv_new_uri(world, LV2_UNITS__unit);
3164         units_render       = lilv_new_uri(world, LV2_UNITS__render);
3165         units_hz           = lilv_new_uri(world, LV2_UNITS__hz);
3166         units_midiNote     = lilv_new_uri(world, LV2_UNITS__midiNote);
3167         units_db           = lilv_new_uri(world, LV2_UNITS__db);
3168         patch_writable     = lilv_new_uri(world, LV2_PATCH__writable);
3169         patch_Message      = lilv_new_uri(world, LV2_PATCH__Message);
3170 #ifdef LV2_EXTENDED
3171         lv2_noSampleAccurateCtrl    = lilv_new_uri(world, "http://ardour.org/lv2/ext#noSampleAccurateControls"); // deprecated 2016-09-18
3172         auto_can_write_automatation = lilv_new_uri(world, LV2_AUTOMATE_URI__can_write);
3173         auto_automation_control     = lilv_new_uri(world, LV2_AUTOMATE_URI__control);
3174         auto_automation_controlled  = lilv_new_uri(world, LV2_AUTOMATE_URI__controlled);
3175         auto_automation_controller  = lilv_new_uri(world, LV2_AUTOMATE_URI__controller);
3176 #endif
3177 #ifdef HAVE_LV2_1_2_0
3178         bufz_powerOf2BlockLength = lilv_new_uri(world, LV2_BUF_SIZE__powerOf2BlockLength);
3179         bufz_fixedBlockLength    = lilv_new_uri(world, LV2_BUF_SIZE__fixedBlockLength);
3180         bufz_nominalBlockLength  = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#nominalBlockLength");
3181         bufz_coarseBlockLength   = lilv_new_uri(world, "http://lv2plug.in/ns/ext/buf-size#coarseBlockLength");
3182 #endif
3183
3184 }
3185
3186 LV2World::~LV2World()
3187 {
3188         if (!world) {
3189                 return;
3190         }
3191 #ifdef HAVE_LV2_1_2_0
3192         lilv_node_free(bufz_coarseBlockLength);
3193         lilv_node_free(bufz_nominalBlockLength);
3194         lilv_node_free(bufz_fixedBlockLength);
3195         lilv_node_free(bufz_powerOf2BlockLength);
3196 #endif
3197 #ifdef LV2_EXTENDED
3198         lilv_node_free(lv2_noSampleAccurateCtrl);
3199         lilv_node_free(auto_can_write_automatation);
3200         lilv_node_free(auto_automation_control);
3201         lilv_node_free(auto_automation_controlled);
3202         lilv_node_free(auto_automation_controller);
3203 #endif
3204         lilv_node_free(patch_Message);
3205         lilv_node_free(patch_writable);
3206         lilv_node_free(units_hz);
3207         lilv_node_free(units_midiNote);
3208         lilv_node_free(units_db);
3209         lilv_node_free(units_unit);
3210         lilv_node_free(units_render);
3211         lilv_node_free(ui_externalkx);
3212         lilv_node_free(ui_external);
3213         lilv_node_free(ui_GtkUI);
3214         lilv_node_free(time_Position);
3215         lilv_node_free(rsz_minimumSize);
3216         lilv_node_free(rdfs_comment);
3217         lilv_node_free(rdfs_label);
3218         lilv_node_free(rdfs_range);
3219         lilv_node_free(midi_MidiEvent);
3220         lilv_node_free(lv2_designation);
3221         lilv_node_free(lv2_enumeration);
3222         lilv_node_free(lv2_freewheeling);
3223         lilv_node_free(lv2_toggled);
3224         lilv_node_free(lv2_sampleRate);
3225         lilv_node_free(lv2_reportsLatency);
3226         lilv_node_free(lv2_index);
3227         lilv_node_free(lv2_integer);
3228         lilv_node_free(lv2_isSideChain);
3229         lilv_node_free(lv2_inPlaceBroken);
3230         lilv_node_free(lv2_OutputPort);
3231         lilv_node_free(lv2_InputPort);
3232         lilv_node_free(lv2_ControlPort);
3233         lilv_node_free(lv2_AudioPort);
3234         lilv_node_free(groups_group);
3235         lilv_node_free(groups_element);
3236         lilv_node_free(ext_rangeSteps);
3237         lilv_node_free(ext_notAutomatic);
3238         lilv_node_free(ext_causesArtifacts);
3239         lilv_node_free(ext_expensive);
3240         lilv_node_free(ext_notOnGUI);
3241         lilv_node_free(ext_logarithmic);
3242         lilv_node_free(ev_EventPort);
3243         lilv_node_free(atom_supports);
3244         lilv_node_free(atom_eventTransfer);
3245         lilv_node_free(atom_bufferType);
3246         lilv_node_free(atom_Sequence);
3247         lilv_node_free(atom_Chunk);
3248         lilv_node_free(atom_AtomPort);
3249         lilv_world_free(world);
3250         world = NULL;
3251 }
3252
3253 void
3254 LV2World::load_bundled_plugins(bool verbose)
3255 {
3256         if (!_bundle_checked) {
3257                 if (verbose) {
3258                         cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
3259                 }
3260
3261                 vector<string> plugin_objects;
3262                 find_paths_matching_filter (plugin_objects, ARDOUR::lv2_bundled_search_path(), lv2_filter, 0, true, true, true);
3263                 for ( vector<string>::iterator x = plugin_objects.begin(); x != plugin_objects.end (); ++x) {
3264 #ifdef PLATFORM_WINDOWS
3265                         string uri = "file:///" + *x + "/";
3266 #else
3267                         string uri = "file://" + *x + "/";
3268 #endif
3269                         LilvNode *node = lilv_new_uri(world, uri.c_str());
3270                         lilv_world_load_bundle(world, node);
3271                         lilv_node_free(node);
3272                 }
3273
3274                 lilv_world_load_all(world);
3275                 _bundle_checked = true;
3276         }
3277 }
3278
3279 LV2PluginInfo::LV2PluginInfo (const char* plugin_uri)
3280 {
3281         type = ARDOUR::LV2;
3282         _plugin_uri = strdup(plugin_uri);
3283 }
3284
3285 LV2PluginInfo::~LV2PluginInfo()
3286 {
3287         free(_plugin_uri);
3288         _plugin_uri = NULL;
3289 }
3290
3291 PluginPtr
3292 LV2PluginInfo::load(Session& session)
3293 {
3294         try {
3295                 PluginPtr plugin;
3296                 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3297                 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3298                 if (!uri) { throw failed_constructor(); }
3299                 const LilvPlugin* lp = lilv_plugins_get_by_uri(plugins, uri);
3300                 if (!lp) { throw failed_constructor(); }
3301                 plugin.reset(new LV2Plugin(session.engine(), session, lp, session.frame_rate()));
3302                 lilv_node_free(uri);
3303                 plugin->set_info(PluginInfoPtr(shared_from_this ()));
3304                 return plugin;
3305         } catch (failed_constructor& err) {
3306                 return PluginPtr((Plugin*)0);
3307         }
3308
3309         return PluginPtr();
3310 }
3311
3312 std::vector<Plugin::PresetRecord>
3313 LV2PluginInfo::get_presets (bool /*user_only*/) const
3314 {
3315         std::vector<Plugin::PresetRecord> p;
3316 #ifndef NO_PLUGIN_STATE
3317         const LilvPlugin* lp = NULL;
3318         try {
3319                 PluginPtr plugin;
3320                 const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
3321                 LilvNode* uri = lilv_new_uri(_world.world, _plugin_uri);
3322                 if (!uri) { throw failed_constructor(); }
3323                 lp = lilv_plugins_get_by_uri(plugins, uri);
3324                 if (!lp) { throw failed_constructor(); }
3325                 lilv_node_free(uri);
3326         } catch (failed_constructor& err) {
3327                 return p;
3328         }
3329         assert (lp);
3330         // see LV2Plugin::find_presets
3331         LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
3332         LilvNode* pset_Preset   = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
3333         LilvNode* rdfs_label    = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
3334
3335         LilvNodes* presets = lilv_plugin_get_related(lp, pset_Preset);
3336         LILV_FOREACH(nodes, i, presets) {
3337                 const LilvNode* preset = lilv_nodes_get(presets, i);
3338                 lilv_world_load_resource(_world.world, preset);
3339                 LilvNode* name = get_value(_world.world, preset, rdfs_label);
3340                 bool userpreset = true; // TODO
3341                 if (name) {
3342                         p.push_back (Plugin::PresetRecord (lilv_node_as_string(preset), lilv_node_as_string(name), userpreset));
3343                         lilv_node_free(name);
3344                 }
3345         }
3346         lilv_nodes_free(presets);
3347         lilv_node_free(rdfs_label);
3348         lilv_node_free(pset_Preset);
3349         lilv_node_free(lv2_appliesTo);
3350 #endif
3351         return p;
3352 }
3353
3354 bool
3355 LV2PluginInfo::in_category (const std::string &c) const
3356 {
3357         // TODO use untranslated lilv_plugin_get_class()
3358         // match gtk2_ardour/plugin_selector.cc
3359         return category.find(c) != string::npos;
3360 }
3361
3362 bool
3363 LV2PluginInfo::is_instrument () const
3364 {
3365         if (category == "Instrument") {
3366                 return true;
3367         }
3368 #if 1
3369         /* until we make sure that category remains untranslated in the lv2.ttl spec
3370          * and until most instruments also classify themselves as such, there's a 2nd check:
3371          */
3372         if (n_inputs.n_midi() > 0 && n_inputs.n_audio() == 0 && n_outputs.n_audio() > 0) {
3373                 return true;
3374         }
3375 #endif
3376         return false;
3377 }
3378
3379 PluginInfoList*
3380 LV2PluginInfo::discover()
3381 {
3382         LV2World world;
3383         world.load_bundled_plugins();
3384         _world.load_bundled_plugins(true);
3385
3386         PluginInfoList*    plugs   = new PluginInfoList;
3387         const LilvPlugins* plugins = lilv_world_get_all_plugins(world.world);
3388
3389         LILV_FOREACH(plugins, i, plugins) {
3390                 const LilvPlugin* p = lilv_plugins_get(plugins, i);
3391                 const LilvNode* pun = lilv_plugin_get_uri(p);
3392                 if (!pun) continue;
3393                 LV2PluginInfoPtr info(new LV2PluginInfo(lilv_node_as_string(pun)));
3394
3395                 LilvNode* name = lilv_plugin_get_name(p);
3396                 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
3397                         warning << "Ignoring invalid LV2 plugin "
3398                                 << lilv_node_as_string(lilv_plugin_get_uri(p))
3399                                 << endmsg;
3400                         continue;
3401                 }
3402
3403                 if (lilv_plugin_has_feature(p, world.lv2_inPlaceBroken)) {
3404                         warning << string_compose(
3405                             _("Ignoring LV2 plugin \"%1\" since it cannot do inplace processing."),
3406                             lilv_node_as_string(name)) << endmsg;
3407                         lilv_node_free(name);
3408                         continue;
3409                 }
3410
3411 #ifdef HAVE_LV2_1_2_0
3412                 LilvNodes *required_features = lilv_plugin_get_required_features (p);
3413                 if (lilv_nodes_contains (required_features, world.bufz_powerOf2BlockLength) ||
3414                                 lilv_nodes_contains (required_features, world.bufz_fixedBlockLength)
3415                    ) {
3416                         warning << string_compose(
3417                             _("Ignoring LV2 plugin \"%1\" because its buffer-size requirements cannot be satisfied."),
3418                             lilv_node_as_string(name)) << endmsg;
3419                         lilv_nodes_free(required_features);
3420                         lilv_node_free(name);
3421                         continue;
3422                 }
3423                 lilv_nodes_free(required_features);
3424 #endif
3425
3426                 info->type = LV2;
3427
3428                 info->name = string(lilv_node_as_string(name));
3429                 lilv_node_free(name);
3430                 ARDOUR::PluginScanMessage(_("LV2"), info->name, false);
3431
3432                 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
3433                 const LilvNode*        label  = lilv_plugin_class_get_label(pclass);
3434                 info->category = lilv_node_as_string(label);
3435
3436                 LilvNode* author_name = lilv_plugin_get_author_name(p);
3437                 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
3438                 lilv_node_free(author_name);
3439
3440                 info->path = "/NOPATH"; // Meaningless for LV2
3441
3442                 /* count atom-event-ports that feature
3443                  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
3444                  *
3445                  * TODO: nicely ask drobilla to make a lilv_ call for that
3446                  */
3447                 int count_midi_out = 0;
3448                 int count_midi_in = 0;
3449                 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
3450                         const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
3451                         if (lilv_port_is_a(p, port, world.atom_AtomPort)) {
3452                                 LilvNodes* buffer_types = lilv_port_get_value(
3453                                         p, port, world.atom_bufferType);
3454                                 LilvNodes* atom_supports = lilv_port_get_value(
3455                                         p, port, world.atom_supports);
3456
3457                                 if (lilv_nodes_contains(buffer_types, world.atom_Sequence)
3458                                                 && lilv_nodes_contains(atom_supports, world.midi_MidiEvent)) {
3459                                         if (lilv_port_is_a(p, port, world.lv2_InputPort)) {
3460                                                 count_midi_in++;
3461                                         }
3462                                         if (lilv_port_is_a(p, port, world.lv2_OutputPort)) {
3463                                                 count_midi_out++;
3464                                         }
3465                                 }
3466                                 lilv_nodes_free(buffer_types);
3467                                 lilv_nodes_free(atom_supports);
3468                         }
3469                 }
3470
3471                 info->n_inputs.set_audio(
3472                         lilv_plugin_get_num_ports_of_class(
3473                                 p, world.lv2_InputPort, world.lv2_AudioPort, NULL));
3474                 info->n_inputs.set_midi(
3475                         lilv_plugin_get_num_ports_of_class(
3476                                 p, world.lv2_InputPort, world.ev_EventPort, NULL)
3477                         + count_midi_in);
3478
3479                 info->n_outputs.set_audio(
3480                         lilv_plugin_get_num_ports_of_class(
3481                                 p, world.lv2_OutputPort, world.lv2_AudioPort, NULL));
3482                 info->n_outputs.set_midi(
3483                         lilv_plugin_get_num_ports_of_class(
3484                                 p, world.lv2_OutputPort, world.ev_EventPort, NULL)
3485                         + count_midi_out);
3486
3487                 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
3488                 info->index     = 0; // Meaningless for LV2
3489
3490                 plugs->push_back(info);
3491         }
3492
3493         return plugs;
3494 }