libs/ardour/lv2_plugin.cc

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