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