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