libs/ardour/lv2_plugin.cc

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