libs/ardour/lv2_plugin.cc

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