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