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