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