libs/ardour/lv2_plugin.cc

   1 /*
   2     Copyright (C) 2008-2012 Paul Davis
   3     Author: David Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <string>
  21 #include <vector>
  22 #include <limits>
  23
  24 #include <cmath>
  25 #include <cstdlib>
  26 #include <cstring>
  27
  28 #include <glib/gstdio.h>
  29 #include <giomm/file.h>
  30 #include <glib/gprintf.h>
  31 #include <glibmm.h>
  32
  33 #include <boost/utility.hpp>
  34
  35 #include "pbd/pathscanner.h"
  36 #include "pbd/compose.h"
  37 #include "pbd/error.h"
  38 #include "pbd/xml++.h"
  39
  40 #include "libardour-config.h"
  41
  42 #include "ardour/audio_buffer.h"
  43 #include "ardour/audioengine.h"
  44 #include "ardour/debug.h"
  45 #include "ardour/lv2_plugin.h"
  46 #include "ardour/session.h"
  47 #include "ardour/tempo.h"
  48 #include "ardour/types.h"
  49 #include "ardour/utils.h"
  50 #include "ardour/worker.h"
  51 #include "ardour/lv2_bundled_search_path.h"
  52
  53 #include "i18n.h"
  54 #include <locale.h>
  55
  56 #include <lilv/lilv.h>
  57
  58 #include "lv2/lv2plug.in/ns/ext/atom/atom.h"
  59 #include "lv2/lv2plug.in/ns/ext/atom/forge.h"
  60 #include "lv2/lv2plug.in/ns/ext/log/log.h"
  61 #include "lv2/lv2plug.in/ns/ext/midi/midi.h"
  62 #include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
  63 #include "lv2/lv2plug.in/ns/ext/presets/presets.h"
  64 #include "lv2/lv2plug.in/ns/ext/state/state.h"
  65 #include "lv2/lv2plug.in/ns/ext/time/time.h"
  66 #include "lv2/lv2plug.in/ns/ext/worker/worker.h"
  67 #include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
  68 #include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
  69 #ifdef HAVE_NEW_LV2
  70 #include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
  71 #include "lv2/lv2plug.in/ns/ext/options/options.h"
  72 #endif
  73
  74 #include "lv2_evbuf.h"
  75
  76 #ifdef HAVE_SUIL
  77 #include <suil/suil.h>
  78 #endif
  79
  80 /** The number of MIDI buffers that will fit in a UI/worker comm buffer.
  81     This needs to be roughly the number of cycles the UI will get around to
  82     actually processing the traffic.  Lower values are flakier but save memory.
  83 */
  84 static const size_t NBUFS = 4;
  85
  86 using namespace std;
  87 using namespace ARDOUR;
  88 using namespace PBD;
  89
  90 URIMap LV2Plugin::_uri_map;
  91
  92 LV2Plugin::URIDs LV2Plugin::urids = {
  93         _uri_map.uri_to_id(LV2_ATOM__Chunk),
  94         _uri_map.uri_to_id(LV2_ATOM__Path),
  95         _uri_map.uri_to_id(LV2_ATOM__Sequence),
  96         _uri_map.uri_to_id(LV2_ATOM__eventTransfer),
  97         _uri_map.uri_to_id(LV2_LOG__Error),
  98         _uri_map.uri_to_id(LV2_LOG__Note),
  99         _uri_map.uri_to_id(LV2_LOG__Warning),
 100         _uri_map.uri_to_id(LV2_MIDI__MidiEvent),
 101         _uri_map.uri_to_id(LV2_TIME__Position),
 102         _uri_map.uri_to_id(LV2_TIME__bar),
 103         _uri_map.uri_to_id(LV2_TIME__barBeat),
 104         _uri_map.uri_to_id(LV2_TIME__beatUnit),
 105         _uri_map.uri_to_id(LV2_TIME__beatsPerBar),
 106         _uri_map.uri_to_id(LV2_TIME__beatsPerMinute),
 107         _uri_map.uri_to_id(LV2_TIME__frame),
 108         _uri_map.uri_to_id(LV2_TIME__speed)
 109 };
 110
 111 class LV2World : boost::noncopyable {
 112 public:
 113         LV2World ();
 114         ~LV2World ();
 115
 116         void load_bundled_plugins();
 117
 118         LilvWorld* world;
 119
 120         LilvNode* atom_AtomPort;
 121         LilvNode* atom_Chunk;
 122         LilvNode* atom_Sequence;
 123         LilvNode* atom_bufferType;
 124         LilvNode* atom_eventTransfer;
 125         LilvNode* atom_supports;
 126         LilvNode* ev_EventPort;
 127         LilvNode* ext_logarithmic;
 128         LilvNode* ext_notOnGUI;
 129         LilvNode* lv2_AudioPort;
 130         LilvNode* lv2_ControlPort;
 131         LilvNode* lv2_InputPort;
 132         LilvNode* lv2_OutputPort;
 133         LilvNode* lv2_enumeration;
 134         LilvNode* lv2_freewheeling;
 135         LilvNode* lv2_inPlaceBroken;
 136         LilvNode* lv2_integer;
 137         LilvNode* lv2_reportsLatency;
 138         LilvNode* lv2_sampleRate;
 139         LilvNode* lv2_toggled;
 140         LilvNode* midi_MidiEvent;
 141         LilvNode* rdfs_comment;
 142         LilvNode* rsz_minimumSize;
 143         LilvNode* time_Position;
 144         LilvNode* ui_GtkUI;
 145         LilvNode* ui_external;
 146
 147 private:
 148         bool _bundle_checked;
 149 };
 150
 151 static LV2World _world;
 152
 153 /* worker extension */
 154
 155 /** Called by the plugin to schedule non-RT work. */
 156 static LV2_Worker_Status
 157 work_schedule(LV2_Worker_Schedule_Handle handle,
 158               uint32_t                   size,
 159               const void*                data)
 160 {
 161         LV2Plugin* plugin = (LV2Plugin*)handle;
 162         if (plugin->session().engine().freewheeling()) {
 163                 // Freewheeling, do the work immediately in this (audio) thread
 164                 return (LV2_Worker_Status)plugin->work(size, data);
 165         } else {
 166                 // Enqueue message for the worker thread
 167                 return plugin->worker()->schedule(size, data) ?
 168                         LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
 169         }
 170 }
 171
 172 /** Called by the plugin to respond to non-RT work. */
 173 static LV2_Worker_Status
 174 work_respond(LV2_Worker_Respond_Handle handle,
 175              uint32_t                  size,
 176              const void*               data)
 177 {
 178         LV2Plugin* plugin = (LV2Plugin*)handle;
 179         if (plugin->session().engine().freewheeling()) {
 180                 // Freewheeling, respond immediately in this (audio) thread
 181                 return (LV2_Worker_Status)plugin->work_response(size, data);
 182         } else {
 183                 // Enqueue response for the worker
 184                 return plugin->worker()->respond(size, data) ?
 185                         LV2_WORKER_SUCCESS : LV2_WORKER_ERR_UNKNOWN;
 186         }
 187 }
 188
 189 /* log extension */
 190
 191 static int
 192 log_vprintf(LV2_Log_Handle /*handle*/,
 193             LV2_URID       type,
 194             const char*    fmt,
 195             va_list        args)
 196 {
 197         char* str = NULL;
 198         const int ret = g_vasprintf(&str, fmt, args);
 199         if (type == LV2Plugin::urids.log_Error) {
 200                 error << str << endmsg;
 201         } else if (type == LV2Plugin::urids.log_Warning) {
 202                 warning << str << endmsg;
 203         } else if (type == LV2Plugin::urids.log_Note) {
 204                 info << str << endmsg;
 205         }
 206         // TODO: Toggleable log:Trace message support
 207         return ret;
 208 }
 209
 210 static int
 211 log_printf(LV2_Log_Handle handle,
 212            LV2_URID       type,
 213            const char*    fmt, ...)
 214 {
 215         va_list args;
 216         va_start(args, fmt);
 217         const int ret = log_vprintf(handle, type, fmt, args);
 218         va_end(args);
 219         return ret;
 220 }
 221
 222 struct LV2Plugin::Impl {
 223         Impl() : plugin(0), ui(0), ui_type(0), name(0), author(0), instance(0)
 224                , work_iface(0)
 225                , state(0)
 226         {}
 227
 228         /** Find the LV2 input port with the given designation.
 229          * If found, bufptrs[port_index] will be set to bufptr.
 230          */
 231         const LilvPort* designated_input (const char* uri, void** bufptrs[], void** bufptr);
 232
 233         const LilvPlugin*           plugin;
 234         const LilvUI*               ui;
 235         const LilvNode*             ui_type;
 236         LilvNode*                   name;
 237         LilvNode*                   author;
 238         LilvInstance*               instance;
 239         const LV2_Worker_Interface* work_iface;
 240         LilvState*                  state;
 241         LV2_Atom_Forge              forge;
 242 };
 243
 244 LV2Plugin::LV2Plugin (AudioEngine& engine,
 245                       Session&     session,
 246                       const void*  c_plugin,
 247                       framecnt_t   rate)
 248         : Plugin (engine, session)
 249         , Workee ()
 250         , _impl(new Impl())
 251         , _features(NULL)
 252         , _worker(NULL)
 253         , _insert_id("0")
 254 {
 255         init(c_plugin, rate);
 256 }
 257
 258 LV2Plugin::LV2Plugin (const LV2Plugin& other)
 259         : Plugin (other)
 260         , Workee ()
 261         , _impl(new Impl())
 262         , _features(NULL)
 263         , _worker(NULL)
 264         , _insert_id(other._insert_id)
 265 {
 266         init(other._impl->plugin, other._sample_rate);
 267
 268         for (uint32_t i = 0; i < parameter_count(); ++i) {
 269                 _control_data[i] = other._shadow_data[i];
 270                 _shadow_data[i]  = other._shadow_data[i];
 271         }
 272 }
 273
 274 void
 275 LV2Plugin::init(const void* c_plugin, framecnt_t rate)
 276 {
 277         DEBUG_TRACE(DEBUG::LV2, "init\n");
 278
 279         _impl->plugin           = (const LilvPlugin*)c_plugin;
 280         _impl->ui               = NULL;
 281         _impl->ui_type          = NULL;
 282         _to_ui                  = NULL;
 283         _from_ui                = NULL;
 284         _control_data           = 0;
 285         _shadow_data            = 0;
 286         _atom_ev_buffers        = 0;
 287         _ev_buffers             = 0;
 288         _bpm_control_port       = 0;
 289         _freewheel_control_port = 0;
 290         _latency_control_port   = 0;
 291         _next_cycle_start       = std::numeric_limits<framepos_t>::max();
 292         _next_cycle_speed       = 1.0;
 293         _block_length           = _engine.frames_per_cycle();
 294         _seq_size               = _engine.raw_buffer_size(DataType::MIDI);
 295         _state_version          = 0;
 296         _was_activated          = false;
 297         _has_state_interface    = false;
 298
 299         _instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
 300         _data_access_feature.URI     = "http://lv2plug.in/ns/ext/data-access";
 301         _make_path_feature.URI       = LV2_STATE__makePath;
 302         _log_feature.URI             = LV2_LOG__log;
 303         _work_schedule_feature.URI   = LV2_WORKER__schedule;
 304         _work_schedule_feature.data  = NULL;
 305         _def_state_feature.URI       = LV2_STATE_PREFIX "loadDefaultState";  // Post LV2-1.2.0
 306         _def_state_feature.data      = NULL;
 307
 308         const LilvPlugin* plugin = _impl->plugin;
 309
 310         LilvNode* state_iface_uri = lilv_new_uri(_world.world, LV2_STATE__interface);
 311         LilvNode* state_uri       = lilv_new_uri(_world.world, LV2_STATE_URI);
 312         _has_state_interface =
 313                 // What plugins should have (lv2:extensionData state:Interface)
 314                 lilv_plugin_has_extension_data(plugin, state_iface_uri)
 315                 // What some outdated/incorrect ones have
 316                 || lilv_plugin_has_feature(plugin, state_uri);
 317         lilv_node_free(state_uri);
 318         lilv_node_free(state_iface_uri);
 319
 320         _features    = (LV2_Feature**)calloc(11, sizeof(LV2_Feature*));
 321         _features[0] = &_instance_access_feature;
 322         _features[1] = &_data_access_feature;
 323         _features[2] = &_make_path_feature;
 324         _features[3] = _uri_map.uri_map_feature();
 325         _features[4] = _uri_map.urid_map_feature();
 326         _features[5] = _uri_map.urid_unmap_feature();
 327         _features[6] = &_log_feature;
 328
 329         unsigned n_features = 7;
 330 #ifdef HAVE_NEW_LV2
 331         _features[n_features++] = &_def_state_feature;
 332 #endif
 333
 334         lv2_atom_forge_init(&_impl->forge, _uri_map.urid_map());
 335
 336 #ifdef HAVE_NEW_LV2
 337         LV2_URID atom_Int = _uri_map.uri_to_id(LV2_ATOM__Int);
 338         LV2_Options_Option options[] = {
 339                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__minBlockLength),
 340                   sizeof(int32_t), atom_Int, &_block_length },
 341                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__maxBlockLength),
 342                   sizeof(int32_t), atom_Int, &_block_length },
 343                 { LV2_OPTIONS_INSTANCE, 0, _uri_map.uri_to_id(LV2_BUF_SIZE__sequenceSize),
 344                   sizeof(int32_t), atom_Int, &_seq_size },
 345                 { LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
 346         };
 347
 348         _options_feature.URI    = LV2_OPTIONS__options;
 349         _options_feature.data   = options;
 350         _features[n_features++] = &_options_feature;
 351 #endif
 352
 353         LV2_State_Make_Path* make_path = (LV2_State_Make_Path*)malloc(
 354                 sizeof(LV2_State_Make_Path));
 355         make_path->handle = this;
 356         make_path->path = &lv2_state_make_path;
 357         _make_path_feature.data = make_path;
 358
 359         LV2_Log_Log* log = (LV2_Log_Log*)malloc(sizeof(LV2_Log_Log));
 360         log->handle  = this;
 361         log->printf  = &log_printf;
 362         log->vprintf = &log_vprintf;
 363         _log_feature.data = log;
 364
 365         LilvNode* worker_schedule = lilv_new_uri(_world.world, LV2_WORKER__schedule);
 366         if (lilv_plugin_has_feature(plugin, worker_schedule)) {
 367                 LV2_Worker_Schedule* schedule = (LV2_Worker_Schedule*)malloc(
 368                         sizeof(LV2_Worker_Schedule));
 369                 size_t buf_size = _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS;
 370                 _worker                     = new Worker(this, buf_size);
 371                 schedule->handle            = this;
 372                 schedule->schedule_work     = work_schedule;
 373                 _work_schedule_feature.data = schedule;
 374                 _features[n_features++]     = &_work_schedule_feature;
 375         }
 376         lilv_node_free(worker_schedule);
 377
 378         _impl->instance = lilv_plugin_instantiate(plugin, rate, _features);
 379         _impl->name     = lilv_plugin_get_name(plugin);
 380         _impl->author   = lilv_plugin_get_author_name(plugin);
 381
 382         if (_impl->instance == 0) {
 383                 error << _("LV2: Failed to instantiate plugin ") << uri() << endmsg;
 384                 throw failed_constructor();
 385         }
 386
 387         _instance_access_feature.data              = (void*)_impl->instance->lv2_handle;
 388         _data_access_extension_data.extension_data = _impl->instance->lv2_descriptor->extension_data;
 389         _data_access_feature.data                  = &_data_access_extension_data;
 390
 391         LilvNode* worker_iface_uri = lilv_new_uri(_world.world, LV2_WORKER__interface);
 392         if (lilv_plugin_has_extension_data(plugin, worker_iface_uri)) {
 393                 _impl->work_iface = (const LV2_Worker_Interface*)extension_data(
 394                         LV2_WORKER__interface);
 395         }
 396         lilv_node_free(worker_iface_uri);
 397
 398         if (lilv_plugin_has_feature(plugin, _world.lv2_inPlaceBroken)) {
 399                 error << string_compose(
 400                     _("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
 401                     lilv_node_as_string(_impl->name)) << endmsg;
 402                 lilv_node_free(_impl->name);
 403                 lilv_node_free(_impl->author);
 404                 throw failed_constructor();
 405         }
 406
 407 #ifdef HAVE_NEW_LILV
 408         // Load default state
 409         LilvState* state = lilv_state_new_from_world(
 410                 _world.world, _uri_map.urid_map(), lilv_plugin_get_uri(_impl->plugin));
 411         if (state && _has_state_interface) {
 412                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
 413         }
 414 #endif
 415
 416         _sample_rate = rate;
 417
 418         const uint32_t num_ports = this->num_ports();
 419         for (uint32_t i = 0; i < num_ports; ++i) {
 420                 const LilvPort* port  = lilv_plugin_get_port_by_index(_impl->plugin, i);
 421                 PortFlags       flags = 0;
 422                 size_t          minimumSize = 0;
 423
 424                 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_OutputPort)) {
 425                         flags |= PORT_OUTPUT;
 426                 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_InputPort)) {
 427                         flags |= PORT_INPUT;
 428                 } else {
 429                         error << string_compose(
 430                                 "LV2: \"%1\" port %2 is neither input nor output",
 431                                 lilv_node_as_string(_impl->name), i) << endmsg;
 432                         throw failed_constructor();
 433                 }
 434
 435                 if (lilv_port_is_a(_impl->plugin, port, _world.lv2_ControlPort)) {
 436                         flags |= PORT_CONTROL;
 437                 } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) {
 438                         flags |= PORT_AUDIO;
 439                 } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) {
 440                         flags |= PORT_EVENT;
 441                         flags |= PORT_MIDI;  // We assume old event API ports are for MIDI
 442                 } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) {
 443                         LilvNodes* buffer_types = lilv_port_get_value(
 444                                 _impl->plugin, port, _world.atom_bufferType);
 445                         LilvNodes* atom_supports = lilv_port_get_value(
 446                                 _impl->plugin, port, _world.atom_supports);
 447
 448                         if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)) {
 449                                 flags |= PORT_SEQUENCE;
 450                                 if (lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
 451                                         flags |= PORT_MIDI;
 452                                 }
 453                                 if (lilv_nodes_contains(atom_supports, _world.time_Position)) {
 454                                         flags |= PORT_POSITION;
 455                                 }
 456                         }
 457                         LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
 458                         LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
 459                         if (min_size && lilv_node_is_int(min_size)) {
 460                                 minimumSize = lilv_node_as_int(min_size);
 461                         }
 462                         lilv_nodes_free(min_size_v);
 463                         lilv_nodes_free(buffer_types);
 464                         lilv_nodes_free(atom_supports);
 465                 } else {
 466                         error << string_compose(
 467                                 "LV2: \"%1\" port %2 has no known data type",
 468                                 lilv_node_as_string(_impl->name), i) << endmsg;
 469                         throw failed_constructor();
 470                 }
 471
 472                 _port_flags.push_back(flags);
 473                 _port_minimumSize.push_back(minimumSize);
 474         }
 475
 476         _control_data = new float[num_ports];
 477         _shadow_data  = new float[num_ports];
 478         _defaults     = new float[num_ports];
 479         _ev_buffers   = new LV2_Evbuf*[num_ports];
 480         memset(_ev_buffers, 0, sizeof(LV2_Evbuf*) * num_ports);
 481
 482         const bool     latent        = lilv_plugin_has_latency(plugin);
 483         const uint32_t latency_index = (latent)
 484                 ? lilv_plugin_get_latency_port_index(plugin)
 485                 : 0;
 486
 487         // Build an array of pointers to special parameter buffers
 488         void*** params = new void**[num_ports];
 489         for (uint32_t i = 0; i < num_ports; ++i) {
 490                 params[i] = NULL;
 491         }
 492         _impl->designated_input (LV2_TIME__beatsPerMinute, params, (void**)&_bpm_control_port);
 493         _impl->designated_input (LV2_CORE__freeWheeling, params, (void**)&_freewheel_control_port);
 494
 495         for (uint32_t i = 0; i < num_ports; ++i) {
 496                 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, i);
 497                 const LilvNode* sym  = lilv_port_get_symbol(plugin, port);
 498
 499                 // Store index in map so we can look up index by symbol
 500                 _port_indices.insert(std::make_pair(lilv_node_as_string(sym), i));
 501
 502                 // Get range and default value if applicable
 503                 if (parameter_is_control(i)) {
 504                         LilvNode* def;
 505                         lilv_port_get_range(plugin, port, &def, NULL, NULL);
 506                         _defaults[i] = def ? lilv_node_as_float(def) : 0.0f;
 507                         if (lilv_port_has_property (plugin, port, _world.lv2_sampleRate)) {
 508                                 _defaults[i] *= _session.frame_rate ();
 509                         }
 510                         lilv_node_free(def);
 511
 512                         lilv_instance_connect_port(_impl->instance, i, &_control_data[i]);
 513
 514                         if (latent && i == latency_index) {
 515                                 _latency_control_port  = &_control_data[i];
 516                                 *_latency_control_port = 0;
 517                         }
 518
 519                         if (parameter_is_input(i)) {
 520                                 _shadow_data[i] = default_value(i);
 521                                 if (params[i]) {
 522                                         *params[i] = (void*)&_shadow_data[i];
 523                                 }
 524                         }
 525                 } else {
 526                         _defaults[i] = 0.0f;
 527                 }
 528         }
 529
 530         delete[] params;
 531
 532         LilvUIs* uis = lilv_plugin_get_uis(plugin);
 533         if (lilv_uis_size(uis) > 0) {
 534 #ifdef HAVE_SUIL
 535                 // Look for embeddable UI
 536                 LILV_FOREACH(uis, u, uis) {
 537                         const LilvUI*   this_ui      = lilv_uis_get(uis, u);
 538                         const LilvNode* this_ui_type = NULL;
 539                         if (lilv_ui_is_supported(this_ui,
 540                                                  suil_ui_supported,
 541                                                  _world.ui_GtkUI,
 542                                                  &this_ui_type)) {
 543                                 // TODO: Multiple UI support
 544                                 _impl->ui      = this_ui;
 545                                 _impl->ui_type = this_ui_type;
 546                                 break;
 547                         }
 548                 }
 549 #else
 550                 // Look for Gtk native UI
 551                 LILV_FOREACH(uis, i, uis) {
 552                         const LilvUI* ui = lilv_uis_get(uis, i);
 553                         if (lilv_ui_is_a(ui, _world.ui_GtkUI)) {
 554                                 _impl->ui      = ui;
 555                                 _impl->ui_type = _world.ui_GtkUI;
 556                                 break;
 557                         }
 558                 }
 559 #endif
 560
 561                 // If Gtk UI is not available, try to find external UI
 562                 if (!_impl->ui) {
 563                         LILV_FOREACH(uis, i, uis) {
 564                                 const LilvUI* ui = lilv_uis_get(uis, i);
 565                                 if (lilv_ui_is_a(ui, _world.ui_external)) {
 566                                         _impl->ui      = ui;
 567                                         _impl->ui_type = _world.ui_external;
 568                                         break;
 569                                 }
 570                         }
 571                 }
 572         }
 573
 574         allocate_atom_event_buffers();
 575         latency_compute_run();
 576 }
 577
 578 LV2Plugin::~LV2Plugin ()
 579 {
 580         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 destroy\n", name()));
 581
 582         deactivate();
 583         cleanup();
 584
 585         lilv_instance_free(_impl->instance);
 586         lilv_node_free(_impl->name);
 587         lilv_node_free(_impl->author);
 588
 589         free(_features);
 590         free(_make_path_feature.data);
 591         free(_work_schedule_feature.data);
 592
 593         delete _to_ui;
 594         delete _from_ui;
 595         delete _worker;
 596
 597         if (_atom_ev_buffers) {
 598                 LV2_Evbuf**  b = _atom_ev_buffers;
 599                 while (*b) {
 600                         free(*b);
 601                         b++;
 602                 }
 603                 free(_atom_ev_buffers);
 604         }
 605
 606         delete [] _control_data;
 607         delete [] _shadow_data;
 608         delete [] _ev_buffers;
 609 }
 610
 611 bool
 612 LV2Plugin::is_external_ui() const
 613 {
 614         if (!_impl->ui) {
 615                 return false;
 616         }
 617         return lilv_ui_is_a(_impl->ui, _world.ui_external);
 618 }
 619
 620 bool
 621 LV2Plugin::ui_is_resizable () const
 622 {
 623         const LilvNode* s   = lilv_ui_get_uri(_impl->ui);
 624         LilvNode*       p   = lilv_new_uri(_world.world, LV2_CORE__optionalFeature);
 625         LilvNode*       fs  = lilv_new_uri(_world.world, LV2_UI__fixedSize);
 626         LilvNode*       nrs = lilv_new_uri(_world.world, LV2_UI__noUserResize);
 627
 628         LilvNodes* fs_matches = lilv_world_find_nodes(_world.world, s, p, fs);
 629         LilvNodes* nrs_matches = lilv_world_find_nodes(_world.world, s, p, nrs);
 630
 631         lilv_nodes_free(nrs_matches);
 632         lilv_nodes_free(fs_matches);
 633         lilv_node_free(nrs);
 634         lilv_node_free(fs);
 635         lilv_node_free(p);
 636
 637         return !fs_matches && !nrs_matches;
 638 }
 639
 640 string
 641 LV2Plugin::unique_id() const
 642 {
 643         return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
 644 }
 645
 646 const char*
 647 LV2Plugin::uri() const
 648 {
 649         return lilv_node_as_uri(lilv_plugin_get_uri(_impl->plugin));
 650 }
 651
 652 const char*
 653 LV2Plugin::label() const
 654 {
 655         return lilv_node_as_string(_impl->name);
 656 }
 657
 658 const char*
 659 LV2Plugin::name() const
 660 {
 661         return lilv_node_as_string(_impl->name);
 662 }
 663
 664 const char*
 665 LV2Plugin::maker() const
 666 {
 667         return _impl->author ? lilv_node_as_string (_impl->author) : "Unknown";
 668 }
 669
 670 uint32_t
 671 LV2Plugin::num_ports() const
 672 {
 673         return lilv_plugin_get_num_ports(_impl->plugin);
 674 }
 675
 676 uint32_t
 677 LV2Plugin::parameter_count() const
 678 {
 679         return lilv_plugin_get_num_ports(_impl->plugin);
 680 }
 681
 682 float
 683 LV2Plugin::default_value(uint32_t port)
 684 {
 685         return _defaults[port];
 686 }
 687
 688 const char*
 689 LV2Plugin::port_symbol(uint32_t index) const
 690 {
 691         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, index);
 692         if (!port) {
 693                 error << name() << ": Invalid port index " << index << endmsg;
 694         }
 695
 696         const LilvNode* sym = lilv_port_get_symbol(_impl->plugin, port);
 697         return lilv_node_as_string(sym);
 698 }
 699
 700 uint32_t
 701 LV2Plugin::port_index (const char* symbol) const
 702 {
 703         const map<string, uint32_t>::const_iterator i = _port_indices.find(symbol);
 704         if (i != _port_indices.end()) {
 705                 return  i->second;
 706         } else {
 707                 warning << string_compose(_("LV2: Unknown port %1"), symbol) << endmsg;
 708                 return (uint32_t)-1;
 709         }
 710 }
 711
 712 void
 713 LV2Plugin::set_parameter(uint32_t which, float val)
 714 {
 715         DEBUG_TRACE(DEBUG::LV2, string_compose(
 716                             "%1 set parameter %2 to %3\n", name(), which, val));
 717
 718         if (which < lilv_plugin_get_num_ports(_impl->plugin)) {
 719                 if (get_parameter (which) == val) {
 720                         return;
 721                 }
 722
 723                 _shadow_data[which] = val;
 724         } else {
 725                 warning << string_compose(
 726                     _("Illegal parameter number used with plugin \"%1\". "
 727                       "This is a bug in either %2 or the LV2 plugin <%3>"),
 728                     name(), PROGRAM_NAME, unique_id()) << endmsg;
 729         }
 730
 731         Plugin::set_parameter(which, val);
 732 }
 733
 734 float
 735 LV2Plugin::get_parameter(uint32_t which) const
 736 {
 737         if (parameter_is_input(which)) {
 738                 return (float)_shadow_data[which];
 739         } else {
 740                 return (float)_control_data[which];
 741         }
 742         return 0.0f;
 743 }
 744
 745 std::string
 746 LV2Plugin::get_docs() const
 747 {
 748         LilvNodes* comments = lilv_plugin_get_value(_impl->plugin, _world.rdfs_comment);
 749         if (comments) {
 750                 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
 751                 lilv_nodes_free(comments);
 752                 return docs;
 753         }
 754
 755         return "";
 756 }
 757
 758 std::string
 759 LV2Plugin::get_parameter_docs(uint32_t which) const
 760 {
 761         LilvNodes* comments = lilv_port_get_value(
 762                 _impl->plugin,
 763                 lilv_plugin_get_port_by_index(_impl->plugin, which),
 764                 _world.rdfs_comment);
 765
 766         if (comments) {
 767                 const std::string docs(lilv_node_as_string(lilv_nodes_get_first(comments)));
 768                 lilv_nodes_free(comments);
 769                 return docs;
 770         }
 771
 772         return "";
 773 }
 774
 775 uint32_t
 776 LV2Plugin::nth_parameter(uint32_t n, bool& ok) const
 777 {
 778         ok = false;
 779         for (uint32_t c = 0, x = 0; x < lilv_plugin_get_num_ports(_impl->plugin); ++x) {
 780                 if (parameter_is_control(x)) {
 781                         if (c++ == n) {
 782                                 ok = true;
 783                                 return x;
 784                         }
 785                 }
 786         }
 787
 788         return 0;
 789 }
 790
 791 const void*
 792 LV2Plugin::extension_data(const char* uri) const
 793 {
 794         return lilv_instance_get_extension_data(_impl->instance, uri);
 795 }
 796
 797 const void*
 798 LV2Plugin::c_plugin()
 799 {
 800         return _impl->plugin;
 801 }
 802
 803 const void*
 804 LV2Plugin::c_ui()
 805 {
 806         return (const void*)_impl->ui;
 807 }
 808
 809 const void*
 810 LV2Plugin::c_ui_type()
 811 {
 812         return (const void*)_impl->ui_type;
 813 }
 814
 815 /** Directory for all plugin state. */
 816 const std::string
 817 LV2Plugin::plugin_dir() const
 818 {
 819         return Glib::build_filename(_session.plugins_dir(), _insert_id.to_s());
 820 }
 821
 822 /** Directory for files created by the plugin (except during save). */
 823 const std::string
 824 LV2Plugin::scratch_dir() const
 825 {
 826         return Glib::build_filename(plugin_dir(), "scratch");
 827 }
 828
 829 /** Directory for snapshots of files in the scratch directory. */
 830 const std::string
 831 LV2Plugin::file_dir() const
 832 {
 833         return Glib::build_filename(plugin_dir(), "files");
 834 }
 835
 836 /** Directory to save state snapshot version @c num into. */
 837 const std::string
 838 LV2Plugin::state_dir(unsigned num) const
 839 {
 840         return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
 841 }
 842
 843 /** Implementation of state:makePath for files created at instantiation time.
 844  * Note this is not used for files created at save time (Lilv deals with that).
 845  */
 846 char*
 847 LV2Plugin::lv2_state_make_path(LV2_State_Make_Path_Handle handle,
 848                                const char*                path)
 849 {
 850         LV2Plugin* me = (LV2Plugin*)handle;
 851         if (me->_insert_id == PBD::ID("0")) {
 852                 warning << string_compose(
 853                         "File path \"%1\" requested but LV2 %2 has no insert ID",
 854                         path, me->name()) << endmsg;
 855                 return g_strdup(path);
 856         }
 857
 858         const std::string abs_path = Glib::build_filename(me->scratch_dir(), path);
 859         const std::string dirname  = Glib::path_get_dirname(abs_path);
 860         g_mkdir_with_parents(dirname.c_str(), 0744);
 861
 862         DEBUG_TRACE(DEBUG::LV2, string_compose("new file path %1 => %2\n",
 863                                                path, abs_path));
 864
 865         return g_strndup(abs_path.c_str(), abs_path.length());
 866 }
 867
 868 static void
 869 remove_directory(const std::string& path)
 870 {
 871         if (!Glib::file_test(path, Glib::FILE_TEST_IS_DIR)) {
 872                 warning << string_compose("\"%1\" is not a directory", path) << endmsg;
 873                 return;
 874         }
 875
 876         Glib::RefPtr<Gio::File>           dir = Gio::File::create_for_path(path);
 877         Glib::RefPtr<Gio::FileEnumerator> e   = dir->enumerate_children();
 878         Glib::RefPtr<Gio::FileInfo>       fi;
 879         while ((fi = e->next_file())) {
 880                 if (fi->get_type() == Gio::FILE_TYPE_DIRECTORY) {
 881                         remove_directory(fi->get_name());
 882                 } else {
 883                         dir->get_child(fi->get_name())->remove();
 884                 }
 885         }
 886         dir->remove();
 887 }
 888
 889 void
 890 LV2Plugin::add_state(XMLNode* root) const
 891 {
 892         assert(_insert_id != PBD::ID("0"));
 893
 894         XMLNode*    child;
 895         char        buf[16];
 896         LocaleGuard lg(X_("POSIX"));
 897
 898         for (uint32_t i = 0; i < parameter_count(); ++i) {
 899                 if (parameter_is_input(i) && parameter_is_control(i)) {
 900                         child = new XMLNode("Port");
 901                         child->add_property("symbol", port_symbol(i));
 902                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
 903                         child->add_property("value", string(buf));
 904                         root->add_child_nocopy(*child);
 905                 }
 906         }
 907
 908         if (_has_state_interface) {
 909                 // Provisionally increment state version and create directory
 910                 const std::string new_dir = state_dir(++_state_version);
 911                 g_mkdir_with_parents(new_dir.c_str(), 0744);
 912
 913                 LilvState* state = lilv_state_new_from_instance(
 914                         _impl->plugin,
 915                         _impl->instance,
 916                         _uri_map.urid_map(),
 917                         scratch_dir().c_str(),
 918                         file_dir().c_str(),
 919                         _session.externals_dir().c_str(),
 920                         new_dir.c_str(),
 921                         NULL,
 922                         const_cast<LV2Plugin*>(this),
 923                         0,
 924                         NULL);
 925
 926                 if (!_impl->state || !lilv_state_equals(state, _impl->state)) {
 927                         lilv_state_save(_world.world,
 928                                         _uri_map.urid_map(),
 929                                         _uri_map.urid_unmap(),
 930                                         state,
 931                                         NULL,
 932                                         new_dir.c_str(),
 933                                         "state.ttl");
 934
 935                         lilv_state_free(_impl->state);
 936                         _impl->state = state;
 937                 } else {
 938                         // State is identical, decrement version and nuke directory
 939                         lilv_state_free(state);
 940                         remove_directory(new_dir);
 941                         --_state_version;
 942                 }
 943
 944                 root->add_property("state-dir", string_compose("state%1", _state_version));
 945         }
 946 }
 947
 948 static inline const LilvNode*
 949 get_value(LilvWorld* world, const LilvNode* subject, const LilvNode* predicate)
 950 {
 951         LilvNodes* vs = lilv_world_find_nodes(world, subject, predicate, NULL);
 952         return vs ? lilv_nodes_get_first(vs) : NULL;
 953 }
 954
 955 void
 956 LV2Plugin::find_presets()
 957 {
 958         LilvNode* lv2_appliesTo = lilv_new_uri(_world.world, LV2_CORE__appliesTo);
 959         LilvNode* pset_Preset   = lilv_new_uri(_world.world, LV2_PRESETS__Preset);
 960         LilvNode* rdfs_label    = lilv_new_uri(_world.world, LILV_NS_RDFS "label");
 961
 962         LilvNodes* presets = lilv_plugin_get_related(_impl->plugin, pset_Preset);
 963         LILV_FOREACH(nodes, i, presets) {
 964                 const LilvNode* preset = lilv_nodes_get(presets, i);
 965                 lilv_world_load_resource(_world.world, preset);
 966                 const LilvNode* name = get_value(_world.world, preset, rdfs_label);
 967                 if (name) {
 968                         _presets.insert(std::make_pair(lilv_node_as_string(preset),
 969                                                        Plugin::PresetRecord(
 970                                                                lilv_node_as_string(preset),
 971                                                                lilv_node_as_string(name))));
 972                 } else {
 973                         warning << string_compose(
 974                             _("Plugin \"%1\% preset \"%2%\" is missing a label\n"),
 975                             lilv_node_as_string(lilv_plugin_get_uri(_impl->plugin)),
 976                             lilv_node_as_string(preset)) << endmsg;
 977                 }
 978         }
 979         lilv_nodes_free(presets);
 980
 981         lilv_node_free(rdfs_label);
 982         lilv_node_free(pset_Preset);
 983         lilv_node_free(lv2_appliesTo);
 984 }
 985
 986 static void
 987 set_port_value(const char* port_symbol,
 988                void*       user_data,
 989                const void* value,
 990                uint32_t    /*size*/,
 991                uint32_t    type)
 992 {
 993         LV2Plugin* self = (LV2Plugin*)user_data;
 994         if (type != 0 && type != self->_uri_map.uri_to_id(LV2_ATOM__Float)) {
 995                 return;  // TODO: Support non-float ports
 996         }
 997
 998         const uint32_t port_index = self->port_index(port_symbol);
 999         if (port_index != (uint32_t)-1) {
1000                 self->set_parameter(port_index, *(const float*)value);
1001         }
1002 }
1003
1004 bool
1005 LV2Plugin::load_preset(PresetRecord r)
1006 {
1007         LilvWorld* world = _world.world;
1008         LilvNode*  pset  = lilv_new_uri(world, r.uri.c_str());
1009         LilvState* state = lilv_state_new_from_world(world, _uri_map.urid_map(), pset);
1010
1011         if (state) {
1012                 lilv_state_restore(state, _impl->instance, set_port_value, this, 0, NULL);
1013                 lilv_state_free(state);
1014         }
1015
1016         lilv_node_free(pset);
1017         return state;
1018 }
1019
1020 const void*
1021 ARDOUR::lv2plugin_get_port_value(const char* port_symbol,
1022                                  void*       user_data,
1023                                  uint32_t*   size,
1024                                  uint32_t*   type)
1025 {
1026         LV2Plugin *plugin = (LV2Plugin *) user_data;
1027
1028         uint32_t index = plugin->port_index(port_symbol);
1029         if (index != (uint32_t) -1) {
1030                 if (plugin->parameter_is_input(index) && plugin->parameter_is_control(index)) {
1031                         float *value;
1032                         *size = sizeof(float);
1033                         *type = plugin->_uri_map.uri_to_id(LV2_ATOM__Float);
1034                         value = &plugin->_shadow_data[index];
1035
1036                         return value;
1037                 }
1038         }
1039
1040         *size = *type = 0;
1041         return NULL;
1042 }
1043
1044
1045 std::string
1046 LV2Plugin::do_save_preset(string name)
1047 {
1048         const string base_name = legalize_for_uri(name);
1049         const string file_name = base_name + ".ttl";
1050         const string bundle    = Glib::build_filename(
1051                 Glib::get_home_dir(),
1052                 Glib::build_filename(".lv2", base_name + ".lv2"));
1053
1054         LilvState* state = lilv_state_new_from_instance(
1055                 _impl->plugin,
1056                 _impl->instance,
1057                 _uri_map.urid_map(),
1058                 scratch_dir().c_str(),                   // file_dir
1059                 bundle.c_str(),                          // copy_dir
1060                 bundle.c_str(),                          // link_dir
1061                 bundle.c_str(),                          // save_dir
1062                 lv2plugin_get_port_value,                // get_value
1063                 (void*)this,                             // user_data
1064                 LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE,  // flags
1065                 _features                                // features
1066         );
1067
1068         lilv_state_set_label(state, name.c_str());
1069         lilv_state_save(
1070                 _world.world,           // world
1071                 _uri_map.urid_map(),    // map
1072                 _uri_map.urid_unmap(),  // unmap
1073                 state,                  // state
1074                 NULL,                   // uri (NULL = use file URI)
1075                 bundle.c_str(),         // dir
1076                 file_name.c_str()       // filename
1077         );
1078
1079         lilv_state_free(state);
1080
1081         return Glib::filename_to_uri(Glib::build_filename(bundle, file_name));
1082 }
1083
1084 void
1085 LV2Plugin::do_remove_preset(string name)
1086 {
1087         string preset_file = Glib::build_filename(
1088                 Glib::get_home_dir(),
1089                 Glib::build_filename(
1090                         Glib::build_filename(".lv2", "presets"),
1091                         name + ".ttl"
1092                 )
1093         );
1094         ::g_unlink(preset_file.c_str());
1095 }
1096
1097 bool
1098 LV2Plugin::has_editor() const
1099 {
1100         return _impl->ui != NULL;
1101 }
1102
1103 bool
1104 LV2Plugin::has_message_output() const
1105 {
1106         for (uint32_t i = 0; i < num_ports(); ++i) {
1107                 if ((_port_flags[i] & PORT_SEQUENCE) &&
1108                     (_port_flags[i] & PORT_OUTPUT)) {
1109                         return true;
1110                 }
1111         }
1112         return false;
1113 }
1114
1115 bool
1116 LV2Plugin::write_to(RingBuffer<uint8_t>* dest,
1117                     uint32_t             index,
1118                     uint32_t             protocol,
1119                     uint32_t             size,
1120                     const uint8_t*       body)
1121 {
1122         const uint32_t buf_size = sizeof(UIMessage) + size;
1123         uint8_t        buf[buf_size];
1124
1125         UIMessage* msg = (UIMessage*)buf;
1126         msg->index    = index;
1127         msg->protocol = protocol;
1128         msg->size     = size;
1129         memcpy(msg + 1, body, size);
1130
1131         return (dest->write(buf, buf_size) == buf_size);
1132 }
1133
1134 bool
1135 LV2Plugin::write_from_ui(uint32_t       index,
1136                          uint32_t       protocol,
1137                          uint32_t       size,
1138                          const uint8_t* body)
1139 {
1140         if (!_from_ui) {
1141                 _from_ui = new RingBuffer<uint8_t>(
1142                         _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS);
1143         }
1144
1145         if (!write_to(_from_ui, index, protocol, size, body)) {
1146                 error << "Error writing from UI to plugin" << endmsg;
1147                 return false;
1148         }
1149         return true;
1150 }
1151
1152 bool
1153 LV2Plugin::write_to_ui(uint32_t       index,
1154                        uint32_t       protocol,
1155                        uint32_t       size,
1156                        const uint8_t* body)
1157 {
1158         if (!write_to(_to_ui, index, protocol, size, body)) {
1159                 error << "Error writing from plugin to UI" << endmsg;
1160                 return false;
1161         }
1162         return true;
1163 }
1164
1165 void
1166 LV2Plugin::enable_ui_emmission()
1167 {
1168         if (!_to_ui) {
1169                 _to_ui = new RingBuffer<uint8_t>(
1170                         _session.engine().raw_buffer_size(DataType::MIDI) * NBUFS);
1171         }
1172 }
1173
1174 void
1175 LV2Plugin::emit_to_ui(void* controller, UIMessageSink sink)
1176 {
1177         if (!_to_ui) {
1178                 return;
1179         }
1180
1181         uint32_t read_space = _to_ui->read_space();
1182         while (read_space > sizeof(UIMessage)) {
1183                 UIMessage msg;
1184                 if (_to_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1185                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1186                         break;
1187                 }
1188                 uint8_t body[msg.size];
1189                 if (_to_ui->read(body, msg.size) != msg.size) {
1190                         error << "Error reading from Plugin=>UI RingBuffer" << endmsg;
1191                         break;
1192                 }
1193
1194                 sink(controller, msg.index, msg.size, msg.protocol, body);
1195
1196                 read_space -= sizeof(msg) + msg.size;
1197         }
1198 }
1199
1200 int
1201 LV2Plugin::work(uint32_t size, const void* data)
1202 {
1203         return _impl->work_iface->work(
1204                 _impl->instance->lv2_handle, work_respond, this, size, data);
1205 }
1206
1207 int
1208 LV2Plugin::work_response(uint32_t size, const void* data)
1209 {
1210         return _impl->work_iface->work_response(
1211                 _impl->instance->lv2_handle, size, data);
1212 }
1213
1214 void
1215 LV2Plugin::set_insert_info(const PluginInsert* insert)
1216 {
1217         _insert_id = insert->id();
1218 }
1219
1220 int
1221 LV2Plugin::set_state(const XMLNode& node, int version)
1222 {
1223         XMLNodeList          nodes;
1224         const XMLProperty*   prop;
1225         XMLNodeConstIterator iter;
1226         XMLNode*             child;
1227         const char*          sym;
1228         const char*          value;
1229         uint32_t             port_id;
1230         LocaleGuard          lg(X_("POSIX"));
1231
1232         if (node.name() != state_node_name()) {
1233                 error << _("Bad node sent to LV2Plugin::set_state") << endmsg;
1234                 return -1;
1235         }
1236
1237 #ifndef NO_PLUGIN_STATE
1238
1239         if (version < 3000) {
1240                 nodes = node.children("port");
1241         } else {
1242                 nodes = node.children("Port");
1243         }
1244
1245         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
1246
1247                 child = *iter;
1248
1249                 if ((prop = child->property("symbol")) != 0) {
1250                         sym = prop->value().c_str();
1251                 } else {
1252                         warning << _("LV2: port has no symbol, ignored") << endmsg;
1253                         continue;
1254                 }
1255
1256                 map<string, uint32_t>::iterator i = _port_indices.find(sym);
1257
1258                 if (i != _port_indices.end()) {
1259                         port_id = i->second;
1260                 } else {
1261                         warning << _("LV2: port has unknown index, ignored") << endmsg;
1262                         continue;
1263                 }
1264
1265                 if ((prop = child->property("value")) != 0) {
1266                         value = prop->value().c_str();
1267                 } else {
1268                         warning << _("LV2: port has no value, ignored") << endmsg;
1269                         continue;
1270                 }
1271
1272                 set_parameter(port_id, atof(value));
1273         }
1274
1275         _state_version = 0;
1276         if ((prop = node.property("state-dir")) != 0) {
1277                 if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
1278                         error << string_compose(
1279                                 "LV2: failed to parse state version from \"%1\"",
1280                                 prop->value()) << endmsg;
1281                 }
1282
1283                 std::string state_file = Glib::build_filename(
1284                         plugin_dir(),
1285                         Glib::build_filename(prop->value(), "state.ttl"));
1286
1287                 LilvState* state = lilv_state_new_from_file(
1288                         _world.world, _uri_map.urid_map(), NULL, state_file.c_str());
1289
1290                 lilv_state_restore(state, _impl->instance, NULL, NULL, 0, NULL);
1291         }
1292
1293         latency_compute_run();
1294 #endif
1295
1296         return Plugin::set_state(node, version);
1297 }
1298
1299 int
1300 LV2Plugin::get_parameter_descriptor(uint32_t which, ParameterDescriptor& desc) const
1301 {
1302         const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, which);
1303
1304         LilvNode *def, *min, *max;
1305         lilv_port_get_range(_impl->plugin, port, &def, &min, &max);
1306
1307         desc.integer_step = lilv_port_has_property(_impl->plugin, port, _world.lv2_integer);
1308         desc.toggled      = lilv_port_has_property(_impl->plugin, port, _world.lv2_toggled);
1309         desc.logarithmic  = lilv_port_has_property(_impl->plugin, port, _world.ext_logarithmic);
1310         desc.sr_dependent = lilv_port_has_property(_impl->plugin, port, _world.lv2_sampleRate);
1311         desc.label        = lilv_node_as_string(lilv_port_get_name(_impl->plugin, port));
1312         desc.lower        = min ? lilv_node_as_float(min) : 0.0f;
1313         desc.upper        = max ? lilv_node_as_float(max) : 1.0f;
1314         if (desc.sr_dependent) {
1315                 desc.lower *= _session.frame_rate ();
1316                 desc.upper *= _session.frame_rate ();
1317         }
1318
1319         desc.min_unbound  = false; // TODO: LV2 extension required
1320         desc.max_unbound  = false; // TODO: LV2 extension required
1321
1322         if (desc.integer_step) {
1323                 desc.step      = 1.0;
1324                 desc.smallstep = 0.1;
1325                 desc.largestep = 10.0;
1326         } else {
1327                 const float delta = desc.upper - desc.lower;
1328                 desc.step      = delta / 1000.0f;
1329                 desc.smallstep = delta / 10000.0f;
1330                 desc.largestep = delta / 10.0f;
1331         }
1332
1333         desc.enumeration = lilv_port_has_property(_impl->plugin, port, _world.lv2_enumeration);
1334
1335         lilv_node_free(def);
1336         lilv_node_free(min);
1337         lilv_node_free(max);
1338
1339         return 0;
1340 }
1341
1342 string
1343 LV2Plugin::describe_parameter(Evoral::Parameter which)
1344 {
1345         if (( which.type() == PluginAutomation) && ( which.id() < parameter_count()) ) {
1346
1347                 if (lilv_port_has_property(_impl->plugin,
1348                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.ext_notOnGUI)) {
1349                         return X_("hidden");
1350                 }
1351
1352                 if (lilv_port_has_property(_impl->plugin,
1353                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_freewheeling)) {
1354                         return X_("hidden");
1355                 }
1356
1357                 if (lilv_port_has_property(_impl->plugin,
1358                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_sampleRate)) {
1359                         return X_("hidden");
1360                 }
1361
1362                 if (lilv_port_has_property(_impl->plugin,
1363                                         lilv_plugin_get_port_by_index(_impl->plugin, which.id()), _world.lv2_reportsLatency)) {
1364                         return X_("latency");
1365                 }
1366
1367                 LilvNode* name = lilv_port_get_name(_impl->plugin,
1368                                                     lilv_plugin_get_port_by_index(_impl->plugin, which.id()));
1369                 string ret(lilv_node_as_string(name));
1370                 lilv_node_free(name);
1371                 return ret;
1372         } else {
1373                 return "??";
1374         }
1375 }
1376
1377 framecnt_t
1378 LV2Plugin::signal_latency() const
1379 {
1380         if (_latency_control_port) {
1381                 return (framecnt_t)floor(*_latency_control_port);
1382         } else {
1383                 return 0;
1384         }
1385 }
1386
1387 set<Evoral::Parameter>
1388 LV2Plugin::automatable() const
1389 {
1390         set<Evoral::Parameter> ret;
1391
1392         for (uint32_t i = 0; i < parameter_count(); ++i) {
1393                 if (parameter_is_input(i) && parameter_is_control(i)) {
1394                         ret.insert(ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
1395                 }
1396         }
1397
1398         return ret;
1399 }
1400
1401 void
1402 LV2Plugin::activate()
1403 {
1404         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 activate\n", name()));
1405
1406         if (!_was_activated) {
1407                 lilv_instance_activate(_impl->instance);
1408                 _was_activated = true;
1409         }
1410 }
1411
1412 void
1413 LV2Plugin::deactivate()
1414 {
1415         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 deactivate\n", name()));
1416
1417         if (_was_activated) {
1418                 lilv_instance_deactivate(_impl->instance);
1419                 _was_activated = false;
1420         }
1421 }
1422
1423 void
1424 LV2Plugin::cleanup()
1425 {
1426         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 cleanup\n", name()));
1427
1428         activate();
1429         deactivate();
1430         lilv_instance_free(_impl->instance);
1431         _impl->instance = NULL;
1432 }
1433
1434 void
1435 LV2Plugin::allocate_atom_event_buffers()
1436 {
1437         /* reserve local scratch buffers for ATOM event-queues */
1438         const LilvPlugin* p = _impl->plugin;
1439
1440         /* count non-MIDI atom event-ports
1441          * TODO: nicely ask drobilla to make a lilv_ call for that
1442          */
1443         int count_atom_out = 0;
1444         int count_atom_in = 0;
1445         int minimumSize = 32768; // TODO use a per-port minimum-size
1446         for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
1447                 const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
1448                 if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
1449                         LilvNodes* buffer_types = lilv_port_get_value(
1450                                 p, port, _world.atom_bufferType);
1451                         LilvNodes* atom_supports = lilv_port_get_value(
1452                                 p, port, _world.atom_supports);
1453
1454                         if (!lilv_nodes_contains(buffer_types, _world.atom_Sequence)
1455                                         || !lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
1456                                 if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
1457                                         count_atom_in++;
1458                                 }
1459                                 if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
1460                                         count_atom_out++;
1461                                 }
1462                                 LilvNodes* min_size_v = lilv_port_get_value(_impl->plugin, port, _world.rsz_minimumSize);
1463                                 LilvNode* min_size = min_size_v ? lilv_nodes_get_first(min_size_v) : NULL;
1464                                 if (min_size && lilv_node_is_int(min_size)) {
1465                                         minimumSize = std::max(minimumSize, lilv_node_as_int(min_size));
1466                                 }
1467                                 lilv_nodes_free(min_size_v);
1468                         }
1469                         lilv_nodes_free(buffer_types);
1470                         lilv_nodes_free(atom_supports);
1471                 }
1472         }
1473
1474         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 need buffers for %2 atom-in and %3 atom-out event-ports\n",
1475                                 name(), count_atom_in, count_atom_out));
1476
1477         const int total_atom_buffers = (count_atom_in + count_atom_out);
1478         if (_atom_ev_buffers || total_atom_buffers == 0) {
1479                 return;
1480         }
1481
1482         DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers\n", total_atom_buffers));
1483         _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*));
1484         for (int i = 0; i < total_atom_buffers; ++i ) {
1485                 _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM,
1486                                 LV2Plugin::urids.atom_Chunk, LV2Plugin::urids.atom_Sequence);
1487         }
1488         _atom_ev_buffers[total_atom_buffers] = 0;
1489         return;
1490 }
1491
1492 /** Write an ardour position/time/tempo/meter as an LV2 event.
1493  * @return true on success.
1494  */
1495 static bool
1496 write_position(LV2_Atom_Forge*     forge,
1497                LV2_Evbuf*          buf,
1498                const TempoMetric&  t,
1499                Timecode::BBT_Time& bbt,
1500                double              speed,
1501                framepos_t          position,
1502                framecnt_t          offset)
1503 {
1504         uint8_t pos_buf[256];
1505         lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
1506         LV2_Atom_Forge_Frame frame;
1507         lv2_atom_forge_blank(forge, &frame, 1, LV2Plugin::urids.time_Position);
1508         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_frame, 0);
1509         lv2_atom_forge_long(forge, position);
1510         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_speed, 0);
1511         lv2_atom_forge_float(forge, speed);
1512         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_barBeat, 0);
1513         lv2_atom_forge_float(forge, bbt.beats - 1 +
1514                              (bbt.ticks / Timecode::BBT_Time::ticks_per_beat));
1515         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_bar, 0);
1516         lv2_atom_forge_long(forge, bbt.bars - 1);
1517         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatUnit, 0);
1518         lv2_atom_forge_int(forge, t.meter().note_divisor());
1519         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatsPerBar, 0);
1520         lv2_atom_forge_float(forge, t.meter().divisions_per_bar());
1521         lv2_atom_forge_property_head(forge, LV2Plugin::urids.time_beatsPerMinute, 0);
1522         lv2_atom_forge_float(forge, t.tempo().beats_per_minute());
1523
1524         LV2_Evbuf_Iterator    end  = lv2_evbuf_end(buf);
1525         const LV2_Atom* const atom = (const LV2_Atom*)pos_buf;
1526         return lv2_evbuf_write(&end, offset, 0, atom->type, atom->size,
1527                                (const uint8_t*)(atom + 1));
1528 }
1529
1530 int
1531 LV2Plugin::connect_and_run(BufferSet& bufs,
1532         ChanMapping in_map, ChanMapping out_map,
1533         pframes_t nframes, framecnt_t offset)
1534 {
1535         DEBUG_TRACE(DEBUG::LV2, string_compose("%1 run %2 offset %3\n", name(), nframes, offset));
1536         Plugin::connect_and_run(bufs, in_map, out_map, nframes, offset);
1537
1538         cycles_t then = get_cycles();
1539
1540         TempoMap&               tmap     = _session.tempo_map();
1541         Metrics::const_iterator metric_i = tmap.metrics_end();
1542         TempoMetric             tmetric  = tmap.metric_at(_session.transport_frame(), &metric_i);
1543
1544         if (_freewheel_control_port) {
1545                 *_freewheel_control_port = _session.engine().freewheeling();
1546         }
1547
1548         if (_bpm_control_port) {
1549                 *_bpm_control_port = tmetric.tempo().beats_per_minute();
1550         }
1551
1552         ChanCount bufs_count;
1553         bufs_count.set(DataType::AUDIO, 1);
1554         bufs_count.set(DataType::MIDI, 1);
1555         BufferSet& silent_bufs  = _session.get_silent_buffers(bufs_count);
1556         BufferSet& scratch_bufs = _session.get_scratch_buffers(bufs_count);
1557         uint32_t const num_ports = parameter_count();
1558         uint32_t const nil_index = std::numeric_limits<uint32_t>::max();
1559
1560         uint32_t audio_in_index  = 0;
1561         uint32_t audio_out_index = 0;
1562         uint32_t midi_in_index   = 0;
1563         uint32_t midi_out_index  = 0;
1564         uint32_t atom_port_index = 0;
1565         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1566                 void*     buf   = NULL;
1567                 uint32_t  index = nil_index;
1568                 PortFlags flags = _port_flags[port_index];
1569                 bool      valid = false;
1570                 if (flags & PORT_AUDIO) {
1571                         if (flags & PORT_INPUT) {
1572                                 index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
1573                                 buf = (valid)
1574                                         ? bufs.get_audio(index).data(offset)
1575                                         : silent_bufs.get_audio(0).data(offset);
1576                         } else {
1577                                 index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
1578                                 buf = (valid)
1579                                         ? bufs.get_audio(index).data(offset)
1580                                         : scratch_bufs.get_audio(0).data(offset);
1581                         }
1582                 } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) {
1583                         /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
1584                            be necessary, but the mapping is illegal in some cases.  Ideally
1585                            that should be fixed, but this is easier...
1586                         */
1587                         if (flags & PORT_MIDI) {
1588                                 if (flags & PORT_INPUT) {
1589                                         index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
1590                                 } else {
1591                                         index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
1592                                 }
1593                                 if (valid && bufs.count().n_midi() > index) {
1594                                         /* Note, ensure_lv2_bufsize() is not RT safe!
1595                                          * However free()/alloc() is only called if a
1596                                          * plugin requires a rsz:minimumSize buffersize
1597                                          * and the existing buffer if smaller.
1598                                          */
1599                                         bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]);
1600                                         _ev_buffers[port_index] = bufs.get_lv2_midi(
1601                                                 (flags & PORT_INPUT), index, (flags & PORT_EVENT));
1602                                 }
1603                         } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) {
1604                                 lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true);
1605                                 _ev_buffers[port_index] = _atom_ev_buffers[atom_port_index++];
1606                                 valid                   = true;
1607                         }
1608
1609                         if (valid && (flags & PORT_INPUT)) {
1610                                 Timecode::BBT_Time bbt;
1611                                 if ((flags & PORT_POSITION)) {
1612                                         if (_session.transport_frame() != _next_cycle_start ||
1613                                             _session.transport_speed() != _next_cycle_speed) {
1614                                                 // Transport has changed, write position at cycle start
1615                                                 tmap.bbt_time(_session.transport_frame(), bbt);
1616                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1617                                                                tmetric, bbt, _session.transport_speed(),
1618                                                                _session.transport_frame(), 0);
1619                                         }
1620                                 }
1621
1622                                 // Get MIDI iterator range (empty range if no MIDI)
1623                                 MidiBuffer::iterator m = (index != nil_index)
1624                                         ? bufs.get_midi(index).begin()
1625                                         : silent_bufs.get_midi(0).end();
1626                                 MidiBuffer::iterator m_end = (index != nil_index)
1627                                         ? bufs.get_midi(index).end()
1628                                         : m;
1629
1630                                 // Now merge MIDI and any transport events into the buffer
1631                                 const uint32_t     type = LV2Plugin::urids.midi_MidiEvent;
1632                                 const framepos_t   tend = _session.transport_frame() + nframes;
1633                                 ++metric_i;
1634                                 while (m != m_end || (metric_i != tmap.metrics_end() &&
1635                                                       (*metric_i)->frame() < tend)) {
1636                                         MetricSection* metric = (metric_i != tmap.metrics_end())
1637                                                 ? *metric_i : NULL;
1638                                         if (m != m_end && (!metric || metric->frame() > (*m).time())) {
1639                                                 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
1640                                                 LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
1641                                                 lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
1642                                                 ++m;
1643                                         } else {
1644                                                 tmetric.set_metric(metric);
1645                                                 bbt = metric->start();
1646                                                 write_position(&_impl->forge, _ev_buffers[port_index],
1647                                                                tmetric, bbt, _session.transport_speed(),
1648                                                                metric->frame(),
1649                                                                metric->frame() - _session.transport_frame());
1650                                                 ++metric_i;
1651                                         }
1652                                 }
1653                         } else if (!valid) {
1654                                 // Nothing we understand or care about, connect to scratch
1655                                 _ev_buffers[port_index] = silent_bufs.get_lv2_midi(
1656                                         (flags & PORT_INPUT), 0, (flags & PORT_EVENT));
1657                         }
1658                         buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]);
1659                 } else {
1660                         continue;  // Control port, leave buffer alone
1661                 }
1662                 lilv_instance_connect_port(_impl->instance, port_index, buf);
1663         }
1664
1665         // Read messages from UI and push into appropriate buffers
1666         if (_from_ui) {
1667                 uint32_t read_space = _from_ui->read_space();
1668                 while (read_space > sizeof(UIMessage)) {
1669                         UIMessage msg;
1670                         if (_from_ui->read((uint8_t*)&msg, sizeof(msg)) != sizeof(msg)) {
1671                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1672                                 break;
1673                         }
1674                         uint8_t body[msg.size];
1675                         if (_from_ui->read(body, msg.size) != msg.size) {
1676                                 error << "Error reading from UI=>Plugin RingBuffer" << endmsg;
1677                                 break;
1678                         }
1679                         if (msg.protocol == urids.atom_eventTransfer) {
1680                                 LV2_Evbuf*            buf  = _ev_buffers[msg.index];
1681                                 LV2_Evbuf_Iterator    i    = lv2_evbuf_end(buf);
1682                                 const LV2_Atom* const atom = (const LV2_Atom*)body;
1683                                 if (!lv2_evbuf_write(&i, nframes, 0, atom->type, atom->size,
1684                                                 (const uint8_t*)(atom + 1))) {
1685                                         error << "Failed to write data to LV2 event buffer\n";
1686                                 }
1687                         } else {
1688                                 error << "Received unknown message type from UI" << endmsg;
1689                         }
1690                         read_space -= sizeof(UIMessage) + msg.size;
1691                 }
1692         }
1693
1694         run(nframes);
1695
1696         midi_out_index = 0;
1697         for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
1698                 PortFlags flags = _port_flags[port_index];
1699                 bool      valid = false;
1700
1701                 /* TODO ask drobilla about comment
1702                  * "Make Ardour event buffers generic so plugins can communicate"
1703                  * in libs/ardour/buffer_set.cc:310
1704                  *
1705                  * ideally the user could choose which of the following two modes
1706                  * to use (e.g. instrument/effect chains  MIDI OUT vs MIDI TRHU).
1707                  *
1708                  * This implementation follows the discussion on IRC Mar 16 2013 16:47 UTC
1709                  * 16:51 < drobilla> rgareus: [..] i.e always replace with MIDI output [of LV2 plugin] if it's there
1710                  * 16:52 < drobilla> rgareus: That would probably be good enough [..] to make users not complain
1711                  *                            for quite a while at least ;)
1712                  */
1713                 // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT
1714                 if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) {
1715                         const uint32_t buf_index = out_map.get(
1716                                 DataType::MIDI, midi_out_index++, &valid);
1717                         if (valid) {
1718                                 bufs.forward_lv2_midi(_ev_buffers[port_index], buf_index);
1719                         }
1720                 }
1721                 // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU
1722                 else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
1723                         const uint32_t buf_index = out_map.get(
1724                                 DataType::MIDI, midi_out_index++, &valid);
1725                         if (valid) {
1726                                 bufs.flush_lv2_midi(true, buf_index);
1727                         }
1728                 }
1729
1730                 // Write messages to UI
1731                 if (_to_ui && (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) {
1732                         LV2_Evbuf* buf = _ev_buffers[port_index];
1733                         for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf);
1734                              lv2_evbuf_is_valid(i);
1735                              i = lv2_evbuf_next(i)) {
1736                                 uint32_t frames, subframes, type, size;
1737                                 uint8_t* data;
1738                                 lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data);
1739                                 write_to_ui(port_index, urids.atom_eventTransfer,
1740                                             size + sizeof(LV2_Atom),
1741                                             data - sizeof(LV2_Atom));
1742                         }
1743                 }
1744         }
1745
1746         cycles_t now = get_cycles();
1747         set_cycles((uint32_t)(now - then));
1748
1749         // Update expected transport information for next cycle so we can detect changes
1750         _next_cycle_speed = _session.transport_speed();
1751         _next_cycle_start = _session.transport_frame() + (nframes * _next_cycle_speed);
1752
1753         return 0;
1754 }
1755
1756 bool
1757 LV2Plugin::parameter_is_control(uint32_t param) const
1758 {
1759         assert(param < _port_flags.size());
1760         return _port_flags[param] & PORT_CONTROL;
1761 }
1762
1763 bool
1764 LV2Plugin::parameter_is_audio(uint32_t param) const
1765 {
1766         assert(param < _port_flags.size());
1767         return _port_flags[param] & PORT_AUDIO;
1768 }
1769
1770 bool
1771 LV2Plugin::parameter_is_event(uint32_t param) const
1772 {
1773         assert(param < _port_flags.size());
1774         return _port_flags[param] & PORT_EVENT;
1775 }
1776
1777 bool
1778 LV2Plugin::parameter_is_output(uint32_t param) const
1779 {
1780         assert(param < _port_flags.size());
1781         return _port_flags[param] & PORT_OUTPUT;
1782 }
1783
1784 bool
1785 LV2Plugin::parameter_is_input(uint32_t param) const
1786 {
1787         assert(param < _port_flags.size());
1788         return _port_flags[param] & PORT_INPUT;
1789 }
1790
1791 void
1792 LV2Plugin::print_parameter(uint32_t param, char* buf, uint32_t len) const
1793 {
1794         if (buf && len) {
1795                 if (param < parameter_count()) {
1796                         snprintf(buf, len, "%.3f", get_parameter(param));
1797                 } else {
1798                         strcat(buf, "0");
1799                 }
1800         }
1801 }
1802
1803 boost::shared_ptr<Plugin::ScalePoints>
1804 LV2Plugin::get_scale_points(uint32_t port_index) const
1805 {
1806         const LilvPort*  port   = lilv_plugin_get_port_by_index(_impl->plugin, port_index);
1807         LilvScalePoints* points = lilv_port_get_scale_points(_impl->plugin, port);
1808
1809         boost::shared_ptr<Plugin::ScalePoints> ret;
1810         if (!points) {
1811                 return ret;
1812         }
1813
1814         ret = boost::shared_ptr<Plugin::ScalePoints>(new ScalePoints());
1815
1816         LILV_FOREACH(scale_points, i, points) {
1817                 const LilvScalePoint* p     = lilv_scale_points_get(points, i);
1818                 const LilvNode*       label = lilv_scale_point_get_label(p);
1819                 const LilvNode*       value = lilv_scale_point_get_value(p);
1820                 if (label && (lilv_node_is_float(value) || lilv_node_is_int(value))) {
1821                         ret->insert(make_pair(lilv_node_as_string(label),
1822                                               lilv_node_as_float(value)));
1823                 }
1824         }
1825
1826         lilv_scale_points_free(points);
1827         return ret;
1828 }
1829
1830 void
1831 LV2Plugin::run(pframes_t nframes)
1832 {
1833         uint32_t const N = parameter_count();
1834         for (uint32_t i = 0; i < N; ++i) {
1835                 if (parameter_is_control(i) && parameter_is_input(i)) {
1836                         _control_data[i] = _shadow_data[i];
1837                 }
1838         }
1839
1840         lilv_instance_run(_impl->instance, nframes);
1841
1842         if (_impl->work_iface) {
1843                 _worker->emit_responses();
1844                 if (_impl->work_iface->end_run) {
1845                         _impl->work_iface->end_run(_impl->instance->lv2_handle);
1846                 }
1847         }
1848 }
1849
1850 void
1851 LV2Plugin::latency_compute_run()
1852 {
1853         if (!_latency_control_port) {
1854                 return;
1855         }
1856
1857         // Run the plugin so that it can set its latency parameter
1858
1859         activate();
1860
1861         uint32_t port_index = 0;
1862         uint32_t in_index   = 0;
1863         uint32_t out_index  = 0;
1864
1865         const framecnt_t bufsize = 1024;
1866         float            buffer[bufsize];
1867
1868         memset(buffer, 0, sizeof(float) * bufsize);
1869
1870         // FIXME: Ensure plugins can handle in-place processing
1871
1872         port_index = 0;
1873
1874         while (port_index < parameter_count()) {
1875                 if (parameter_is_audio(port_index)) {
1876                         if (parameter_is_input(port_index)) {
1877                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
1878                                 in_index++;
1879                         } else if (parameter_is_output(port_index)) {
1880                                 lilv_instance_connect_port(_impl->instance, port_index, buffer);
1881                                 out_index++;
1882                         }
1883                 }
1884                 port_index++;
1885         }
1886
1887         run(bufsize);
1888         deactivate();
1889 }
1890
1891 const LilvPort*
1892 LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** bufptr)
1893 {
1894         const LilvPort* port = NULL;
1895         LilvNode* designation = lilv_new_uri(_world.world, uri);
1896         port = lilv_plugin_get_port_by_designation(
1897                 plugin, _world.lv2_InputPort, designation);
1898         lilv_node_free(designation);
1899         if (port) {
1900                 bufptrs[lilv_port_get_index(plugin, port)] = bufptr;
1901         }
1902         return port;
1903 }
1904
1905 static bool lv2_filter (const string& str, void *arg)
1906 {
1907         /* Not a dotfile, has a prefix before a period, suffix is "lv2" */
1908
1909         return str[0] != '.' && (str.length() > 3 && str.find (".lv2") == (str.length() - 4));
1910 }
1911
1912
1913 LV2World::LV2World()
1914         : world(lilv_world_new())
1915         , _bundle_checked(false)
1916 {
1917         lilv_world_load_all(world);
1918
1919         atom_AtomPort      = lilv_new_uri(world, LV2_ATOM__AtomPort);
1920         atom_Chunk         = lilv_new_uri(world, LV2_ATOM__Chunk);
1921         atom_Sequence      = lilv_new_uri(world, LV2_ATOM__Sequence);
1922         atom_bufferType    = lilv_new_uri(world, LV2_ATOM__bufferType);
1923         atom_supports      = lilv_new_uri(world, LV2_ATOM__supports);
1924         atom_eventTransfer = lilv_new_uri(world, LV2_ATOM__eventTransfer);
1925         ev_EventPort       = lilv_new_uri(world, LILV_URI_EVENT_PORT);
1926         ext_logarithmic    = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
1927         ext_notOnGUI       = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
1928         lv2_AudioPort      = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
1929         lv2_ControlPort    = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
1930         lv2_InputPort      = lilv_new_uri(world, LILV_URI_INPUT_PORT);
1931         lv2_OutputPort     = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
1932         lv2_inPlaceBroken  = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
1933         lv2_integer        = lilv_new_uri(world, LV2_CORE__integer);
1934         lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
1935         lv2_sampleRate     = lilv_new_uri(world, LV2_CORE__sampleRate);
1936         lv2_toggled        = lilv_new_uri(world, LV2_CORE__toggled);
1937         lv2_enumeration    = lilv_new_uri(world, LV2_CORE__enumeration);
1938         lv2_freewheeling   = lilv_new_uri(world, LV2_CORE__freeWheeling);
1939         midi_MidiEvent     = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
1940         rdfs_comment       = lilv_new_uri(world, LILV_NS_RDFS "comment");
1941         rsz_minimumSize    = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
1942         time_Position      = lilv_new_uri(world, LV2_TIME__Position);
1943         ui_GtkUI           = lilv_new_uri(world, LV2_UI__GtkUI);
1944         ui_external        = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");
1945 }
1946
1947 LV2World::~LV2World()
1948 {
1949         lilv_node_free(ui_external);
1950         lilv_node_free(ui_GtkUI);
1951         lilv_node_free(time_Position);
1952         lilv_node_free(rsz_minimumSize);
1953         lilv_node_free(rdfs_comment);
1954         lilv_node_free(midi_MidiEvent);
1955         lilv_node_free(lv2_enumeration);
1956         lilv_node_free(lv2_freewheeling);
1957         lilv_node_free(lv2_toggled);
1958         lilv_node_free(lv2_sampleRate);
1959         lilv_node_free(lv2_reportsLatency);
1960         lilv_node_free(lv2_integer);
1961         lilv_node_free(lv2_inPlaceBroken);
1962         lilv_node_free(lv2_OutputPort);
1963         lilv_node_free(lv2_InputPort);
1964         lilv_node_free(lv2_ControlPort);
1965         lilv_node_free(lv2_AudioPort);
1966         lilv_node_free(ext_notOnGUI);
1967         lilv_node_free(ext_logarithmic);
1968         lilv_node_free(ev_EventPort);
1969         lilv_node_free(atom_supports);
1970         lilv_node_free(atom_eventTransfer);
1971         lilv_node_free(atom_bufferType);
1972         lilv_node_free(atom_Sequence);
1973         lilv_node_free(atom_Chunk);
1974         lilv_node_free(atom_AtomPort);
1975 }
1976
1977 void
1978 LV2World::load_bundled_plugins()
1979 {
1980         if (!_bundle_checked) {
1981                 cout << "Scanning folders for bundled LV2s: " << ARDOUR::lv2_bundled_search_path().to_string() << endl;
1982                 PathScanner scanner;
1983                 vector<string *> *plugin_objects = scanner (ARDOUR::lv2_bundled_search_path().to_string(), lv2_filter, 0, true, true);
1984                 if (plugin_objects) {
1985                         for ( vector<string *>::iterator x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
1986 #ifdef WINDOWS
1987                                 string uri = "file:///" + **x + "/";
1988 #else
1989                                 string uri = "file://" + **x + "/";
1990 #endif
1991                                 LilvNode *node = lilv_new_uri(world, uri.c_str());
1992                                 lilv_world_load_bundle(world, node);
1993                                 lilv_node_free(node);
1994                         }
1995                 }
1996                 delete (plugin_objects);
1997
1998                 _bundle_checked = true;
1999         }
2000 }
2001
2002 LV2PluginInfo::LV2PluginInfo (const void* c_plugin)
2003         : _c_plugin(c_plugin)
2004 {
2005         type = ARDOUR::LV2;
2006 }
2007
2008 LV2PluginInfo::~LV2PluginInfo()
2009 {}
2010
2011 PluginPtr
2012 LV2PluginInfo::load(Session& session)
2013 {
2014         try {
2015                 PluginPtr plugin;
2016
2017                 plugin.reset(new LV2Plugin(session.engine(), session,
2018                                            (const LilvPlugin*)_c_plugin,
2019                                            session.frame_rate()));
2020
2021                 plugin->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
2022                 return plugin;
2023         } catch (failed_constructor& err) {
2024                 return PluginPtr((Plugin*)0);
2025         }
2026
2027         return PluginPtr();
2028 }
2029
2030 PluginInfoList*
2031 LV2PluginInfo::discover()
2032 {
2033         _world.load_bundled_plugins();
2034
2035         PluginInfoList*    plugs   = new PluginInfoList;
2036         const LilvPlugins* plugins = lilv_world_get_all_plugins(_world.world);
2037
2038         info << "LV2: Discovering " << lilv_plugins_size(plugins) << " plugins" << endmsg;
2039
2040         LILV_FOREACH(plugins, i, plugins) {
2041                 const LilvPlugin* p = lilv_plugins_get(plugins, i);
2042                 LV2PluginInfoPtr  info(new LV2PluginInfo((const void*)p));
2043
2044                 LilvNode* name = lilv_plugin_get_name(p);
2045                 if (!name || !lilv_plugin_get_port_by_index(p, 0)) {
2046                         warning << "Ignoring invalid LV2 plugin "
2047                                 << lilv_node_as_string(lilv_plugin_get_uri(p))
2048                                 << endmsg;
2049                         continue;
2050                 }
2051
2052                 info->type = LV2;
2053
2054                 info->name = string(lilv_node_as_string(name));
2055                 lilv_node_free(name);
2056
2057                 const LilvPluginClass* pclass = lilv_plugin_get_class(p);
2058                 const LilvNode*        label  = lilv_plugin_class_get_label(pclass);
2059                 info->category = lilv_node_as_string(label);
2060
2061                 LilvNode* author_name = lilv_plugin_get_author_name(p);
2062                 info->creator = author_name ? string(lilv_node_as_string(author_name)) : "Unknown";
2063                 lilv_node_free(author_name);
2064
2065                 info->path = "/NOPATH"; // Meaningless for LV2
2066
2067                 /* count atom-event-ports that feature
2068                  * atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent>
2069                  *
2070                  * TODO: nicely ask drobilla to make a lilv_ call for that
2071                  */
2072                 int count_midi_out = 0;
2073                 int count_midi_in = 0;
2074                 for (uint32_t i = 0; i < lilv_plugin_get_num_ports(p); ++i) {
2075                         const LilvPort* port  = lilv_plugin_get_port_by_index(p, i);
2076                         if (lilv_port_is_a(p, port, _world.atom_AtomPort)) {
2077                                 LilvNodes* buffer_types = lilv_port_get_value(
2078                                         p, port, _world.atom_bufferType);
2079                                 LilvNodes* atom_supports = lilv_port_get_value(
2080                                         p, port, _world.atom_supports);
2081
2082                                 if (lilv_nodes_contains(buffer_types, _world.atom_Sequence)
2083                                                 && lilv_nodes_contains(atom_supports, _world.midi_MidiEvent)) {
2084                                         if (lilv_port_is_a(p, port, _world.lv2_InputPort)) {
2085                                                 count_midi_in++;
2086                                         }
2087                                         if (lilv_port_is_a(p, port, _world.lv2_OutputPort)) {
2088                                                 count_midi_out++;
2089                                         }
2090                                 }
2091                                 lilv_nodes_free(buffer_types);
2092                                 lilv_nodes_free(atom_supports);
2093                         }
2094                 }
2095
2096                 info->n_inputs.set_audio(
2097                         lilv_plugin_get_num_ports_of_class(
2098                                 p, _world.lv2_InputPort, _world.lv2_AudioPort, NULL));
2099                 info->n_inputs.set_midi(
2100                         lilv_plugin_get_num_ports_of_class(
2101                                 p, _world.lv2_InputPort, _world.ev_EventPort, NULL)
2102                         + count_midi_in);
2103
2104                 info->n_outputs.set_audio(
2105                         lilv_plugin_get_num_ports_of_class(
2106                                 p, _world.lv2_OutputPort, _world.lv2_AudioPort, NULL));
2107                 info->n_outputs.set_midi(
2108                         lilv_plugin_get_num_ports_of_class(
2109                                 p, _world.lv2_OutputPort, _world.ev_EventPort, NULL)
2110                         + count_midi_out);
2111
2112                 info->unique_id = lilv_node_as_uri(lilv_plugin_get_uri(p));
2113                 info->index     = 0; // Meaningless for LV2
2114
2115                 plugs->push_back(info);
2116         }
2117
2118         return plugs;
2119 }