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