falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4718 Commits
16 Branches
14GB
Tree: ebdfa4046d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ebdfa4046d'
${ noResults }
Carla/source/utils/CarlaLv2Utils.hpp

2796 lines
112KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 utils

  3.  * Copyright (C) 2011-2019 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or 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.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #ifndef CARLA_LV2_UTILS_HPP_INCLUDED

  19. #define CARLA_LV2_UTILS_HPP_INCLUDED

  20. 

  21. #include "CarlaMathUtils.hpp"

  22. 

  23. #ifndef nullptr

  24. # undef NULL

  25. # define NULL nullptr

  26. #endif

  27. 

  28. // disable -Wdocumentation for LV2 headers

  29. #if defined(__clang__) && (__clang_major__ * 100 + __clang_minor__) > 300

  30. # pragma clang diagnostic push

  31. # pragma clang diagnostic ignored "-Wdocumentation"

  32. #endif

  33. 

  34. #include "lv2/lv2.h"

  35. #include "lv2/atom.h"

  36. #include "lv2/atom-forge.h"

  37. #include "lv2/atom-helpers.h"

  38. #include "lv2/atom-util.h"

  39. #include "lv2/buf-size.h"

  40. #include "lv2/data-access.h"

  41. // dynmanifest

  42. #include "lv2/event.h"

  43. #include "lv2/event-helpers.h"

  44. #include "lv2/inline-display.h"

  45. #include "lv2/instance-access.h"

  46. #include "lv2/log.h"

  47. // logger

  48. #include "lv2/midi.h"

  49. // morph

  50. #include "lv2/options.h"

  51. #include "lv2/parameters.h"

  52. #include "lv2/patch.h"

  53. #include "lv2/port-groups.h"

  54. #include "lv2/port-props.h"

  55. #include "lv2/presets.h"

  56. #include "lv2/resize-port.h"

  57. #include "lv2/state.h"

  58. #include "lv2/time.h"

  59. #include "lv2/ui.h"

  60. #include "lv2/units.h"

  61. #include "lv2/uri-map.h"

  62. #include "lv2/urid.h"

  63. #include "lv2/worker.h"

  64. 

  65. #include "lv2/lv2-miditype.h"

  66. #include "lv2/lv2-midifunctions.h"

  67. #include "lv2/lv2_external_ui.h"

  68. #include "lv2/lv2_kxstudio_properties.h"

  69. #include "lv2/lv2_programs.h"

  70. #include "lv2/lv2_rtmempool.h"

  71. 

  72. #include "lilv/lilvmm.hpp"

  73. #include "sratom/sratom.h"

  74. #include "lilv/config/lilv_config.h"

  75. 

  76. // enable -Wdocumentation again

  77. #if defined(__clang__) && (__clang_major__ * 100 + __clang_minor__) > 300

  78. # pragma clang diagnostic pop

  79. #endif

  80. 

  81. #include "lv2_rdf.hpp"

  82. 

  83. #ifdef USE_QT

  84. # include <QtCore/QStringList>

  85. #else

  86. # include "water/text/StringArray.h"

  87. #endif

  88. 

  89. // used for scalepoint sorting

  90. #include <map>

  91. typedef std::map<double,const LilvScalePoint*> LilvScalePointMap;

  92. 

  93. // --------------------------------------------------------------------------------------------------------------------

  94. // Define namespaces and missing prefixes

  95. 

  96. #define NS_dct  "http://purl.org/dc/terms/"

  97. #define NS_doap "http://usefulinc.com/ns/doap#"

  98. #define NS_rdf  "http://www.w3.org/1999/02/22-rdf-syntax-ns#"

  99. #define NS_rdfs "http://www.w3.org/2000/01/rdf-schema#"

  100. #define NS_llmm "http://ll-plugins.nongnu.org/lv2/ext/midimap#"

  101. #define NS_devp "http://lv2plug.in/ns/dev/extportinfo#"

  102. 

  103. #define LV2_MIDI_Map__CC      "http://ll-plugins.nongnu.org/lv2/namespace#CC"

  104. #define LV2_MIDI_Map__NRPN    "http://ll-plugins.nongnu.org/lv2/namespace#NRPN"

  105. 

  106. #define LV2_MIDI_LL__MidiPort "http://ll-plugins.nongnu.org/lv2/ext/MidiPort"

  107. 

  108. #define LV2_UI__makeResident       LV2_UI_PREFIX "makeResident"

  109. #define LV2_UI__makeSONameResident LV2_UI_PREFIX "makeSONameResident"

  110. 

  111. // TODO: update LV2 headers once again

  112. #define LV2_CORE__Parameter LV2_CORE_PREFIX "Parameter" ///< http://lv2plug.in/ns/lv2core#Parameter

  113. #define LV2_CORE__enabled   LV2_CORE_PREFIX "enabled"   ///< http://lv2plug.in/ns/lv2core#enabled

  114. 

  115. // --------------------------------------------------------------------------------------------------------------------

  116. // Custom Atom types

  117. 

  118. struct LV2_Atom_MidiEvent {

  119.     LV2_Atom atom;    /**< Atom header. */

  120.     uint8_t  data[4]; /**< MIDI data (body). */

  121. };

  122. 

  123. static inline

  124. uint32_t lv2_atom_total_size(const LV2_Atom_MidiEvent& midiEv)

  125. {

  126.     return static_cast<uint32_t>(sizeof(LV2_Atom)) + midiEv.atom.size;

  127. }

  128. 

  129. // ---------------------------------------------------------------------------------------------------------------------

  130. // -Weffc++ compat ext widget

  131. 

  132. extern "C" {

  133. 

  134. typedef struct _LV2_External_UI_Widget_Compat {

  135.   void (*run )(struct _LV2_External_UI_Widget_Compat*);

  136.   void (*show)(struct _LV2_External_UI_Widget_Compat*);

  137.   void (*hide)(struct _LV2_External_UI_Widget_Compat*);

  138. 

  139.   _LV2_External_UI_Widget_Compat() noexcept

  140.       : run(nullptr), show(nullptr), hide(nullptr) {}

  141. 

  142. } LV2_External_UI_Widget_Compat;

  143. 

  144. }

  145. 

  146. // --------------------------------------------------------------------------------------------------------------------

  147. // Our LV2 World class

  148. 

  149. class Lv2WorldClass : public Lilv::World

  150. {

  151. public:

  152.     // Base Types

  153.     Lilv::Node port;

  154.     Lilv::Node symbol;

  155.     Lilv::Node designation;

  156.     Lilv::Node freeWheeling;

  157.     Lilv::Node reportsLatency;

  158. 

  159.     // Plugin Types

  160.     Lilv::Node class_allpass;

  161.     Lilv::Node class_amplifier;

  162.     Lilv::Node class_analyzer;

  163.     Lilv::Node class_bandpass;

  164.     Lilv::Node class_chorus;

  165.     Lilv::Node class_comb;

  166.     Lilv::Node class_compressor;

  167.     Lilv::Node class_constant;

  168.     Lilv::Node class_converter;

  169.     Lilv::Node class_delay;

  170.     Lilv::Node class_distortion;

  171.     Lilv::Node class_dynamics;

  172.     Lilv::Node class_eq;

  173.     Lilv::Node class_envelope;

  174.     Lilv::Node class_expander;

  175.     Lilv::Node class_filter;

  176.     Lilv::Node class_flanger;

  177.     Lilv::Node class_function;

  178.     Lilv::Node class_gate;

  179.     Lilv::Node class_generator;

  180.     Lilv::Node class_highpass;

  181.     Lilv::Node class_instrument;

  182.     Lilv::Node class_limiter;

  183.     Lilv::Node class_lowpass;

  184.     Lilv::Node class_mixer;

  185.     Lilv::Node class_modulator;

  186.     Lilv::Node class_multiEQ;

  187.     Lilv::Node class_oscillator;

  188.     Lilv::Node class_paraEQ;

  189.     Lilv::Node class_phaser;

  190.     Lilv::Node class_pitch;

  191.     Lilv::Node class_reverb;

  192.     Lilv::Node class_simulator;

  193.     Lilv::Node class_spatial;

  194.     Lilv::Node class_spectral;

  195.     Lilv::Node class_utility;

  196.     Lilv::Node class_waveshaper;

  197. 

  198.     // Port Types

  199.     Lilv::Node port_input;

  200.     Lilv::Node port_output;

  201.     Lilv::Node port_control;

  202.     Lilv::Node port_audio;

  203.     Lilv::Node port_cv;

  204.     Lilv::Node port_atom;

  205.     Lilv::Node port_event;

  206.     Lilv::Node port_midi;

  207. 

  208.     // Port Properties

  209.     Lilv::Node pprop_optional;

  210.     Lilv::Node pprop_enumeration;

  211.     Lilv::Node pprop_integer;

  212.     Lilv::Node pprop_sampleRate;

  213.     Lilv::Node pprop_toggled;

  214.     Lilv::Node pprop_artifacts;

  215.     Lilv::Node pprop_continuousCV;

  216.     Lilv::Node pprop_discreteCV;

  217.     Lilv::Node pprop_expensive;

  218.     Lilv::Node pprop_strictBounds;

  219.     Lilv::Node pprop_logarithmic;

  220.     Lilv::Node pprop_notAutomatic;

  221.     Lilv::Node pprop_notOnGUI;

  222.     Lilv::Node pprop_trigger;

  223.     Lilv::Node pprop_nonAutomable;

  224. 

  225.     // Unit Hints

  226.     Lilv::Node unit_name;

  227.     Lilv::Node unit_render;

  228.     Lilv::Node unit_symbol;

  229.     Lilv::Node unit_unit;

  230. 

  231.     // UI Types

  232.     Lilv::Node ui_gtk2;

  233.     Lilv::Node ui_gtk3;

  234.     Lilv::Node ui_qt4;

  235.     Lilv::Node ui_qt5;

  236.     Lilv::Node ui_cocoa;

  237.     Lilv::Node ui_windows;

  238.     Lilv::Node ui_x11;

  239.     Lilv::Node ui_external;

  240.     Lilv::Node ui_externalOld;

  241.     Lilv::Node ui_externalOld2;

  242. 

  243.     // Misc

  244.     Lilv::Node atom_bufferType;

  245.     Lilv::Node atom_sequence;

  246.     Lilv::Node atom_supports;

  247. 

  248.     Lilv::Node patch_writable;

  249.     Lilv::Node parameter;

  250. 

  251.     Lilv::Node preset_preset;

  252. 

  253.     Lilv::Node state_state;

  254. 

  255.     Lilv::Node ui_portIndex;

  256.     Lilv::Node ui_portNotif;

  257.     Lilv::Node ui_protocol;

  258. 

  259.     Lilv::Node value_default;

  260.     Lilv::Node value_minimum;

  261.     Lilv::Node value_maximum;

  262. 

  263.     Lilv::Node rz_asLargeAs;

  264.     Lilv::Node rz_minSize;

  265. 

  266.     // Port Data Types

  267.     Lilv::Node midi_event;

  268.     Lilv::Node patch_message;

  269.     Lilv::Node time_position;

  270. 

  271.     // MIDI CC

  272.     Lilv::Node mm_defaultControl;

  273.     Lilv::Node mm_controlType;

  274.     Lilv::Node mm_controlNumber;

  275. 

  276.     // Other

  277.     Lilv::Node dct_replaces;

  278.     Lilv::Node doap_license;

  279.     Lilv::Node rdf_type;

  280.     Lilv::Node rdfs_comment;

  281.     Lilv::Node rdfs_label;

  282.     Lilv::Node rdfs_range;

  283. 

  284.     bool needsInit;

  285. 

  286.     const LilvPlugins* allPlugins;

  287.     const LilvPlugin** cachedPlugins;

  288.     uint pluginCount;

  289. 

  290.     // ----------------------------------------------------------------------------------------------------------------

  291. 

  292.     Lv2WorldClass()

  293.         : Lilv::World(),

  294.           port               (new_uri(LV2_CORE__port)),

  295.           symbol             (new_uri(LV2_CORE__symbol)),

  296.           designation        (new_uri(LV2_CORE__designation)),

  297.           freeWheeling       (new_uri(LV2_CORE__freeWheeling)),

  298.           reportsLatency     (new_uri(LV2_CORE__reportsLatency)),

  299. 

  300.           class_allpass      (new_uri(LV2_CORE__AllpassPlugin)),

  301.           class_amplifier    (new_uri(LV2_CORE__AmplifierPlugin)),

  302.           class_analyzer     (new_uri(LV2_CORE__AnalyserPlugin)),

  303.           class_bandpass     (new_uri(LV2_CORE__BandpassPlugin)),

  304.           class_chorus       (new_uri(LV2_CORE__ChorusPlugin)),

  305.           class_comb         (new_uri(LV2_CORE__CombPlugin)),

  306.           class_compressor   (new_uri(LV2_CORE__CompressorPlugin)),

  307.           class_constant     (new_uri(LV2_CORE__ConstantPlugin)),

  308.           class_converter    (new_uri(LV2_CORE__ConverterPlugin)),

  309.           class_delay        (new_uri(LV2_CORE__DelayPlugin)),

  310.           class_distortion   (new_uri(LV2_CORE__DistortionPlugin)),

  311.           class_dynamics     (new_uri(LV2_CORE__DynamicsPlugin)),

  312.           class_eq           (new_uri(LV2_CORE__EQPlugin)),

  313.           class_envelope     (new_uri(LV2_CORE__EnvelopePlugin)),

  314.           class_expander     (new_uri(LV2_CORE__ExpanderPlugin)),

  315.           class_filter       (new_uri(LV2_CORE__FilterPlugin)),

  316.           class_flanger      (new_uri(LV2_CORE__FlangerPlugin)),

  317.           class_function     (new_uri(LV2_CORE__FunctionPlugin)),

  318.           class_gate         (new_uri(LV2_CORE__GatePlugin)),

  319.           class_generator    (new_uri(LV2_CORE__GeneratorPlugin)),

  320.           class_highpass     (new_uri(LV2_CORE__HighpassPlugin)),

  321.           class_instrument   (new_uri(LV2_CORE__InstrumentPlugin)),

  322.           class_limiter      (new_uri(LV2_CORE__LimiterPlugin)),

  323.           class_lowpass      (new_uri(LV2_CORE__LowpassPlugin)),

  324.           class_mixer        (new_uri(LV2_CORE__MixerPlugin)),

  325.           class_modulator    (new_uri(LV2_CORE__ModulatorPlugin)),

  326.           class_multiEQ      (new_uri(LV2_CORE__MultiEQPlugin)),

  327.           class_oscillator   (new_uri(LV2_CORE__OscillatorPlugin)),

  328.           class_paraEQ       (new_uri(LV2_CORE__ParaEQPlugin)),

  329.           class_phaser       (new_uri(LV2_CORE__PhaserPlugin)),

  330.           class_pitch        (new_uri(LV2_CORE__PitchPlugin)),

  331.           class_reverb       (new_uri(LV2_CORE__ReverbPlugin)),

  332.           class_simulator    (new_uri(LV2_CORE__SimulatorPlugin)),

  333.           class_spatial      (new_uri(LV2_CORE__SpatialPlugin)),

  334.           class_spectral     (new_uri(LV2_CORE__SpectralPlugin)),

  335.           class_utility      (new_uri(LV2_CORE__UtilityPlugin)),

  336.           class_waveshaper   (new_uri(LV2_CORE__WaveshaperPlugin)),

  337. 

  338.           port_input         (new_uri(LV2_CORE__InputPort)),

  339.           port_output        (new_uri(LV2_CORE__OutputPort)),

  340.           port_control       (new_uri(LV2_CORE__ControlPort)),

  341.           port_audio         (new_uri(LV2_CORE__AudioPort)),

  342.           port_cv            (new_uri(LV2_CORE__CVPort)),

  343.           port_atom          (new_uri(LV2_ATOM__AtomPort)),

  344.           port_event         (new_uri(LV2_EVENT__EventPort)),

  345.           port_midi          (new_uri(LV2_MIDI_LL__MidiPort)),

  346. 

  347.           pprop_optional     (new_uri(LV2_CORE__connectionOptional)),

  348.           pprop_enumeration  (new_uri(LV2_CORE__enumeration)),

  349.           pprop_integer      (new_uri(LV2_CORE__integer)),

  350.           pprop_sampleRate   (new_uri(LV2_CORE__sampleRate)),

  351.           pprop_toggled      (new_uri(LV2_CORE__toggled)),

  352.           pprop_artifacts    (new_uri(LV2_PORT_PROPS__causesArtifacts)),

  353.           pprop_continuousCV (new_uri(LV2_PORT_PROPS__continuousCV)),

  354.           pprop_discreteCV   (new_uri(LV2_PORT_PROPS__discreteCV)),

  355.           pprop_expensive    (new_uri(LV2_PORT_PROPS__expensive)),

  356.           pprop_strictBounds (new_uri(LV2_PORT_PROPS__hasStrictBounds)),

  357.           pprop_logarithmic  (new_uri(LV2_PORT_PROPS__logarithmic)),

  358.           pprop_notAutomatic (new_uri(LV2_PORT_PROPS__notAutomatic)),

  359.           pprop_notOnGUI     (new_uri(LV2_PORT_PROPS__notOnGUI)),

  360.           pprop_trigger      (new_uri(LV2_PORT_PROPS__trigger)),

  361.           pprop_nonAutomable (new_uri(LV2_KXSTUDIO_PROPERTIES__NonAutomable)),

  362. 

  363.           unit_name          (new_uri(LV2_UNITS__name)),

  364.           unit_render        (new_uri(LV2_UNITS__render)),

  365.           unit_symbol        (new_uri(LV2_UNITS__symbol)),

  366.           unit_unit          (new_uri(LV2_UNITS__unit)),

  367. 

  368.           ui_gtk2            (new_uri(LV2_UI__GtkUI)),

  369.           ui_gtk3            (new_uri(LV2_UI__Gtk3UI)),

  370.           ui_qt4             (new_uri(LV2_UI__Qt4UI)),

  371.           ui_qt5             (new_uri(LV2_UI__Qt5UI)),

  372.           ui_cocoa           (new_uri(LV2_UI__CocoaUI)),

  373.           ui_windows         (new_uri(LV2_UI__WindowsUI)),

  374.           ui_x11             (new_uri(LV2_UI__X11UI)),

  375.           ui_external        (new_uri(LV2_EXTERNAL_UI__Widget)),

  376.           ui_externalOld     (new_uri(LV2_EXTERNAL_UI_DEPRECATED_URI)),

  377.           ui_externalOld2    (new_uri("http://nedko.arnaudov.name/lv2/external_ui/")),

  378. 

  379.           atom_bufferType    (new_uri(LV2_ATOM__bufferType)),

  380.           atom_sequence      (new_uri(LV2_ATOM__Sequence)),

  381.           atom_supports      (new_uri(LV2_ATOM__supports)),

  382. 

  383.           patch_writable     (new_uri(LV2_PATCH__writable)),

  384.           parameter          (new_uri(LV2_CORE__Parameter)),

  385. 

  386.           preset_preset      (new_uri(LV2_PRESETS__Preset)),

  387. 

  388.           state_state        (new_uri(LV2_STATE__state)),

  389. 

  390.           ui_portIndex       (new_uri(LV2_UI__portIndex)),

  391.           ui_portNotif       (new_uri(LV2_UI__portNotification)),

  392.           ui_protocol        (new_uri(LV2_UI__protocol)),

  393. 

  394.           value_default      (new_uri(LV2_CORE__default)),

  395.           value_minimum      (new_uri(LV2_CORE__minimum)),

  396.           value_maximum      (new_uri(LV2_CORE__maximum)),

  397. 

  398.           rz_asLargeAs       (new_uri(LV2_RESIZE_PORT__asLargeAs)),

  399.           rz_minSize         (new_uri(LV2_RESIZE_PORT__minimumSize)),

  400. 

  401.           midi_event         (new_uri(LV2_MIDI__MidiEvent)),

  402.           patch_message      (new_uri(LV2_PATCH__Message)),

  403.           time_position      (new_uri(LV2_TIME__Position)),

  404. 

  405.           mm_defaultControl  (new_uri(NS_llmm "defaultMidiController")),

  406.           mm_controlType     (new_uri(NS_llmm "controllerType")),

  407.           mm_controlNumber   (new_uri(NS_llmm "controllerNumber")),

  408. 

  409.           dct_replaces       (new_uri(NS_dct "replaces")),

  410.           doap_license       (new_uri(NS_doap "license")),

  411.           rdf_type           (new_uri(NS_rdf "type")),

  412.           rdfs_comment       (new_uri(NS_rdfs "comment")),

  413.           rdfs_label         (new_uri(NS_rdfs "label")),

  414.           rdfs_range         (new_uri(NS_rdfs "range")),

  415. 

  416.           needsInit(true),

  417.           allPlugins(nullptr),

  418.           cachedPlugins(nullptr),

  419.           pluginCount(0) {}

  420. 

  421.     ~Lv2WorldClass() override

  422.     {

  423.         pluginCount = 0;

  424.         allPlugins = nullptr;

  425. 

  426.         if (cachedPlugins != nullptr)

  427.         {

  428.             delete[] cachedPlugins;

  429.             cachedPlugins = nullptr;

  430.         }

  431.     }

  432. 

  433.     // FIXME - remove this

  434.     static Lv2WorldClass& getInstance()

  435.     {

  436.         static Lv2WorldClass lv2World;

  437.         return lv2World;

  438.     }

  439. 

  440.     void initIfNeeded(const char* LV2_PATH)

  441.     {

  442.         if (LV2_PATH == nullptr || LV2_PATH[0] == '\0')

  443.         {

  444.             static const char* const DEFAULT_LV2_PATH = LILV_DEFAULT_LV2_PATH;

  445.             LV2_PATH = DEFAULT_LV2_PATH;

  446.         }

  447. 

  448.         if (! needsInit)

  449.             return;

  450. 

  451.         needsInit = false;

  452. 

  453.         Lilv::World::load_all(LV2_PATH);

  454. 

  455.         allPlugins = lilv_world_get_all_plugins(this->me);

  456.         CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr,);

  457. 

  458.         if ((pluginCount = lilv_plugins_size(allPlugins)))

  459.         {

  460.             cachedPlugins = new const LilvPlugin*[pluginCount+1];

  461.             carla_zeroPointers(cachedPlugins, pluginCount+1);

  462. 

  463.             int i = 0;

  464.             for (LilvIter* it = lilv_plugins_begin(allPlugins); ! lilv_plugins_is_end(allPlugins, it); it = lilv_plugins_next(allPlugins, it))

  465.                 cachedPlugins[i++] = lilv_plugins_get(allPlugins, it);

  466.         }

  467.     }

  468. 

  469.     void load_bundle(const char* const bundle)

  470.     {

  471.         CARLA_SAFE_ASSERT_RETURN(bundle != nullptr && bundle[0] != '\0',);

  472.         CARLA_SAFE_ASSERT_RETURN(needsInit,);

  473. 

  474.         needsInit = false;

  475.         Lilv::World::load_bundle(Lilv::Node(new_uri(bundle)));

  476. 

  477.         allPlugins = lilv_world_get_all_plugins(this->me);

  478.         CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr,);

  479. 

  480.         if ((pluginCount = lilv_plugins_size(allPlugins)))

  481.         {

  482.             cachedPlugins = new const LilvPlugin*[pluginCount+1];

  483.             carla_zeroPointers(cachedPlugins, pluginCount+1);

  484. 

  485.             int i = 0;

  486.             for (LilvIter* it = lilv_plugins_begin(allPlugins); ! lilv_plugins_is_end(allPlugins, it); it = lilv_plugins_next(allPlugins, it))

  487.                 cachedPlugins[i++] = lilv_plugins_get(allPlugins, it);

  488.         }

  489.     }

  490. 

  491.     uint getPluginCount() const

  492.     {

  493.         CARLA_SAFE_ASSERT_RETURN(! needsInit, 0);

  494. 

  495.         return pluginCount;

  496.     }

  497. 

  498.     const LilvPlugin* getPluginFromIndex(const uint index) const

  499.     {

  500.         CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);

  501.         CARLA_SAFE_ASSERT_RETURN(cachedPlugins != nullptr, nullptr);

  502.         CARLA_SAFE_ASSERT_RETURN(index < pluginCount, nullptr);

  503. 

  504.         return cachedPlugins[index];

  505.     }

  506. 

  507.     const LilvPlugin* getPluginFromURI(const LV2_URI uri) const

  508.     {

  509.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', nullptr);

  510.         CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);

  511.         CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr, nullptr);

  512. 

  513.         LilvNode* const uriNode(lilv_new_uri(this->me, uri));

  514.         CARLA_SAFE_ASSERT_RETURN(uriNode != nullptr, nullptr);

  515. 

  516.         const LilvPlugin* const cPlugin(lilv_plugins_get_by_uri(allPlugins, uriNode));

  517.         lilv_node_free(uriNode);

  518. 

  519.         return cPlugin;

  520.     }

  521. 

  522.     LilvState* getStateFromURI(const LV2_URI uri, const LV2_URID_Map* const uridMap) const

  523.     {

  524.         CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', nullptr);

  525.         CARLA_SAFE_ASSERT_RETURN(uridMap != nullptr, nullptr);

  526.         CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);

  527. 

  528.         LilvNode* const uriNode(lilv_new_uri(this->me, uri));

  529.         CARLA_SAFE_ASSERT_RETURN(uriNode != nullptr, nullptr);

  530. 

  531.         CARLA_SAFE_ASSERT(lilv_world_load_resource(this->me, uriNode) >= 0);

  532. 

  533.         LilvState* const cState(lilv_state_new_from_world(this->me, uridMap, uriNode));

  534.         lilv_node_free(uriNode);

  535. 

  536.         return cState;

  537.     }

  538. 

  539.     CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION

  540.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2WorldClass)

  541. };

  542. 

  543. // --------------------------------------------------------------------------------------------------------------------

  544. // Our LV2 Plugin base class

  545. 

  546. #if defined(__clang__)

  547. # pragma clang diagnostic push

  548. # pragma clang diagnostic ignored "-Weffc++"

  549. # pragma clang diagnostic ignored "-Wnon-virtual-dtor"

  550. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  551. # pragma GCC diagnostic push

  552. # pragma GCC diagnostic ignored "-Weffc++"

  553. # pragma GCC diagnostic ignored "-Wnon-virtual-dtor"

  554. #endif

  555. template<class TimeInfoStruct>

  556. class Lv2PluginBaseClass : public LV2_External_UI_Widget_Compat

  557. {

  558. #if defined(__clang__)

  559. # pragma clang diagnostic pop

  560. #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  561. # pragma GCC diagnostic pop

  562. #endif

  563. public:

  564.     Lv2PluginBaseClass(const double sampleRate, const LV2_Feature* const* const features)

  565.         : fIsActive(false),

  566.           fIsOffline(false),

  567.           fUsingNominal(false),

  568.           fBufferSize(0),

  569.           fSampleRate(sampleRate),

  570.           fUridMap(nullptr),

  571.           fWorker(nullptr),

  572.           fTimeInfo(),

  573.           fLastPositionData(),

  574.           fPorts(),

  575.           fURIs(),

  576.           fUI()

  577.     {

  578.         run  = extui_run;

  579.         show = extui_show;

  580.         hide = extui_hide;

  581. 

  582.         if (fSampleRate < 1.0)

  583.         {

  584.             carla_stderr("Host doesn't provide a valid sample rate");

  585.             return;

  586.         }

  587. 

  588.         const LV2_Options_Option*  options   = nullptr;

  589.         const LV2_URID_Map*        uridMap   = nullptr;

  590.         const LV2_URID_Unmap*      uridUnmap = nullptr;

  591.         const LV2_Worker_Schedule* worker    = nullptr;

  592. 

  593.         for (int i=0; features[i] != nullptr; ++i)

  594.         {

  595.             /**/ if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)

  596.                 options = (const LV2_Options_Option*)features[i]->data;

  597.             else if (std::strcmp(features[i]->URI, LV2_URID__map) == 0)

  598.                 uridMap = (const LV2_URID_Map*)features[i]->data;

  599.             else if (std::strcmp(features[i]->URI, LV2_URID__unmap) == 0)

  600.                 uridUnmap = (const LV2_URID_Unmap*)features[i]->data;

  601.             else if (std::strcmp(features[i]->URI, LV2_WORKER__schedule) == 0)

  602.                 worker = (const LV2_Worker_Schedule*)features[i]->data;

  603.         }

  604. 

  605.         if (options == nullptr || uridMap == nullptr)

  606.         {

  607.             carla_stderr("Host doesn't provide option and urid-map features");

  608.             return;

  609.         }

  610. 

  611.         for (int i=0; options[i].key != 0; ++i)

  612.         {

  613.             if (uridUnmap != nullptr) {

  614.                 carla_debug("Host option %i:\"%s\"", i, uridUnmap->unmap(uridUnmap->handle, options[i].key));

  615.             }

  616. 

  617.             if (options[i].key == uridMap->map(uridMap->handle, LV2_BUF_SIZE__nominalBlockLength))

  618.             {

  619.                 if (options[i].type == uridMap->map(uridMap->handle, LV2_ATOM__Int))

  620.                 {

  621.                     const int32_t value(*(const int32_t*)options[i].value);

  622.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  623. 

  624.                     fBufferSize = static_cast<uint32_t>(value);

  625.                     fUsingNominal = true;

  626.                 }

  627.                 else

  628.                 {

  629.                     carla_stderr("Host provides nominalBlockLength but has wrong value type");

  630.                 }

  631.                 break;

  632.             }

  633. 

  634.             if (options[i].key == uridMap->map(uridMap->handle, LV2_BUF_SIZE__maxBlockLength))

  635.             {

  636.                 if (options[i].type == uridMap->map(uridMap->handle, LV2_ATOM__Int))

  637.                 {

  638.                     const int32_t value(*(const int32_t*)options[i].value);

  639.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  640. 

  641.                     fBufferSize = static_cast<uint32_t>(value);

  642.                 }

  643.                 else

  644.                 {

  645.                     carla_stderr("Host provides maxBlockLength but has wrong value type");

  646.                 }

  647.                 // no break, continue in case host supports nominalBlockLength

  648.             }

  649.         }

  650. 

  651.         if (fBufferSize == 0)

  652.         {

  653.             carla_stderr("Host doesn't provide buffer-size feature");

  654.             //return;

  655.             // as testing, continue for now

  656.             fBufferSize = 1024;

  657.         }

  658. 

  659.         fUridMap = uridMap;

  660.         fURIs.map(uridMap);

  661. 

  662.         fWorker = worker;

  663. 

  664.         clearTimeData();

  665.     }

  666. 

  667.     virtual ~Lv2PluginBaseClass() {}

  668. 

  669.     bool loadedInProperHost() const noexcept

  670.     {

  671.         return fUridMap != nullptr && fBufferSize != 0;

  672.     }

  673. 

  674.     // ----------------------------------------------------------------------------------------------------------------

  675. 

  676.     void lv2_connect_port(const uint32_t port, void* const dataLocation) noexcept

  677.     {

  678.         fPorts.connectPort(port, dataLocation);

  679.     }

  680. 

  681.     bool lv2_pre_run(const uint32_t frames)

  682.     {

  683.         CARLA_SAFE_ASSERT_RETURN(fIsActive, false);

  684. 

  685.         fIsOffline = (fPorts.freewheel != nullptr && *fPorts.freewheel >= 0.5f);

  686. 

  687.         // cache midi events and time information first

  688.         if (fPorts.usesTime)

  689.         {

  690.             LV2_ATOM_SEQUENCE_FOREACH(fPorts.eventsIn[0], event)

  691.             {

  692.                 if (event == nullptr)

  693.                     continue;

  694.                 if (event->body.type != fURIs.atomBlank && event->body.type != fURIs.atomObject)

  695.                     continue;

  696. 

  697.                 const LV2_Atom_Object* const obj((const LV2_Atom_Object*)&event->body);

  698. 

  699.                 if (obj->body.otype != fURIs.timePos)

  700.                     continue;

  701. 

  702.                 LV2_Atom* bar = nullptr;

  703.                 LV2_Atom* barBeat = nullptr;

  704.                 LV2_Atom* beatUnit = nullptr;

  705.                 LV2_Atom* beatsPerBar = nullptr;

  706.                 LV2_Atom* beatsPerMinute = nullptr;

  707.                 LV2_Atom* frame = nullptr;

  708.                 LV2_Atom* speed = nullptr;

  709.                 LV2_Atom* ticksPerBeat = nullptr;

  710. 

  711.                 lv2_atom_object_get(obj,

  712.                                     fURIs.timeBar, &bar,

  713.                                     fURIs.timeBarBeat, &barBeat,

  714.                                     fURIs.timeBeatUnit, &beatUnit,

  715.                                     fURIs.timeBeatsPerBar, &beatsPerBar,

  716.                                     fURIs.timeBeatsPerMinute, &beatsPerMinute,

  717.                                     fURIs.timeFrame, &frame,

  718.                                     fURIs.timeSpeed, &speed,

  719.                                     fURIs.timeTicksPerBeat, &ticksPerBeat,

  720.                                     0);

  721. 

  722.                 // need to handle this first as other values depend on it

  723.                 if (ticksPerBeat != nullptr)

  724.                 {

  725.                     double ticksPerBeatValue = -1.0;

  726. 

  727.                     /**/ if (ticksPerBeat->type == fURIs.atomDouble)

  728.                         ticksPerBeatValue = ((LV2_Atom_Double*)ticksPerBeat)->body;

  729.                     else if (ticksPerBeat->type == fURIs.atomFloat)

  730.                         ticksPerBeatValue = ((LV2_Atom_Float*)ticksPerBeat)->body;

  731.                     else if (ticksPerBeat->type == fURIs.atomInt)

  732.                         ticksPerBeatValue = static_cast<double>(((LV2_Atom_Int*)ticksPerBeat)->body);

  733.                     else if (ticksPerBeat->type == fURIs.atomLong)

  734.                         ticksPerBeatValue = static_cast<double>(((LV2_Atom_Long*)ticksPerBeat)->body);

  735.                     else

  736.                         carla_stderr("Unknown lv2 ticksPerBeat value type");

  737. 

  738.                     if (ticksPerBeatValue > 0.0)

  739.                         fTimeInfo.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat = ticksPerBeatValue;

  740.                     else

  741.                         carla_stderr("Invalid lv2 ticksPerBeat value");

  742.                 }

  743. 

  744.                 // same

  745.                 if (speed != nullptr)

  746.                 {

  747.                     /**/ if (speed->type == fURIs.atomDouble)

  748.                         fLastPositionData.speed = ((LV2_Atom_Double*)speed)->body;

  749.                     else if (speed->type == fURIs.atomFloat)

  750.                         fLastPositionData.speed = ((LV2_Atom_Float*)speed)->body;

  751.                     else if (speed->type == fURIs.atomInt)

  752.                         fLastPositionData.speed = static_cast<double>(((LV2_Atom_Int*)speed)->body);

  753.                     else if (speed->type == fURIs.atomLong)

  754.                         fLastPositionData.speed = static_cast<double>(((LV2_Atom_Long*)speed)->body);

  755.                     else

  756.                         carla_stderr("Unknown lv2 speed value type");

  757. 

  758.                     fTimeInfo.playing = carla_isNotZero(fLastPositionData.speed);

  759. 

  760.                     if (fTimeInfo.playing && fLastPositionData.beatsPerMinute > 0.0)

  761.                     {

  762.                         fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute*

  763.                                                         std::abs(fLastPositionData.speed);

  764.                     }

  765.                 }

  766. 

  767.                 if (bar != nullptr)

  768.                 {

  769.                     int64_t barValue = -1;

  770. 

  771.                     /**/ if (bar->type == fURIs.atomDouble)

  772.                         barValue = static_cast<int64_t>(((LV2_Atom_Double*)bar)->body);

  773.                     else if (bar->type == fURIs.atomFloat)

  774.                         barValue = static_cast<int64_t>(((LV2_Atom_Float*)bar)->body);

  775.                     else if (bar->type == fURIs.atomInt)

  776.                         barValue = ((LV2_Atom_Int*)bar)->body;

  777.                     else if (bar->type == fURIs.atomLong)

  778.                         barValue = ((LV2_Atom_Long*)bar)->body;

  779.                     else

  780.                         carla_stderr("Unknown lv2 bar value type");

  781. 

  782.                     if (barValue >= 0 && barValue < INT32_MAX)

  783.                     {

  784.                         fLastPositionData.bar   = static_cast<int32_t>(barValue);

  785.                         fLastPositionData.bar_f = static_cast<float>(barValue);

  786.                         fTimeInfo.bbt.bar = fLastPositionData.bar + 1;

  787.                     }

  788.                     else

  789.                     {

  790.                         carla_stderr("Invalid lv2 bar value");

  791.                     }

  792.                 }

  793. 

  794.                 if (barBeat != nullptr)

  795.                 {

  796.                     double barBeatValue = -1.0;

  797. 

  798.                     /**/ if (barBeat->type == fURIs.atomDouble)

  799.                         barBeatValue = ((LV2_Atom_Double*)barBeat)->body;

  800.                     else if (barBeat->type == fURIs.atomFloat)

  801.                         barBeatValue = ((LV2_Atom_Float*)barBeat)->body;

  802.                     else if (barBeat->type == fURIs.atomInt)

  803.                         barBeatValue = static_cast<float>(((LV2_Atom_Int*)barBeat)->body);

  804.                     else if (barBeat->type == fURIs.atomLong)

  805.                         barBeatValue = static_cast<float>(((LV2_Atom_Long*)barBeat)->body);

  806.                     else

  807.                         carla_stderr("Unknown lv2 barBeat value type");

  808. 

  809.                     if (barBeatValue >= 0.0)

  810.                     {

  811.                         fLastPositionData.barBeat = static_cast<float>(barBeatValue);

  812. 

  813.                         const double rest  = std::fmod(barBeatValue, 1.0);

  814.                         fTimeInfo.bbt.beat = static_cast<int32_t>(barBeatValue-rest+1.0);

  815.                         fTimeInfo.bbt.tick = static_cast<int32_t>(rest*fTimeInfo.bbt.ticksPerBeat+0.5);

  816.                     }

  817.                     else

  818.                     {

  819.                         carla_stderr("Invalid lv2 barBeat value");

  820.                     }

  821.                 }

  822. 

  823.                 if (beatUnit != nullptr)

  824.                 {

  825.                     int64_t beatUnitValue = -1;

  826. 

  827.                     /**/ if (beatUnit->type == fURIs.atomDouble)

  828.                         beatUnitValue = static_cast<int64_t>(((LV2_Atom_Double*)beatUnit)->body);

  829.                     else if (beatUnit->type == fURIs.atomFloat)

  830.                         beatUnitValue = static_cast<int64_t>(((LV2_Atom_Float*)beatUnit)->body);

  831.                     else if (beatUnit->type == fURIs.atomInt)

  832.                         beatUnitValue = ((LV2_Atom_Int*)beatUnit)->body;

  833.                     else if (beatUnit->type == fURIs.atomLong)

  834.                         beatUnitValue = ((LV2_Atom_Long*)beatUnit)->body;

  835.                     else

  836.                         carla_stderr("Unknown lv2 beatUnit value type");

  837. 

  838.                     if (beatUnitValue > 0 && beatUnitValue < UINT32_MAX)

  839.                     {

  840.                         fLastPositionData.beatUnit = static_cast<uint32_t>(beatUnitValue);

  841.                         fTimeInfo.bbt.beatType     = static_cast<float>(beatUnitValue);

  842.                     }

  843.                     else

  844.                     {

  845.                         carla_stderr("Invalid lv2 beatUnit value");

  846.                     }

  847.                 }

  848. 

  849.                 if (beatsPerBar != nullptr)

  850.                 {

  851.                     float beatsPerBarValue = -1.0f;

  852. 

  853.                     /**/ if (beatsPerBar->type == fURIs.atomDouble)

  854.                         beatsPerBarValue = static_cast<float>(((LV2_Atom_Double*)beatsPerBar)->body);

  855.                     else if (beatsPerBar->type == fURIs.atomFloat)

  856.                         beatsPerBarValue = ((LV2_Atom_Float*)beatsPerBar)->body;

  857.                     else if (beatsPerBar->type == fURIs.atomInt)

  858.                         beatsPerBarValue = static_cast<float>(((LV2_Atom_Int*)beatsPerBar)->body);

  859.                     else if (beatsPerBar->type == fURIs.atomLong)

  860.                         beatsPerBarValue = static_cast<float>(((LV2_Atom_Long*)beatsPerBar)->body);

  861.                     else

  862.                         carla_stderr("Unknown lv2 beatsPerBar value type");

  863. 

  864.                     if (beatsPerBarValue > 0.0f)

  865.                         fTimeInfo.bbt.beatsPerBar = fLastPositionData.beatsPerBar = beatsPerBarValue;

  866.                     else

  867.                         carla_stderr("Invalid lv2 beatsPerBar value");

  868.                 }

  869. 

  870.                 if (beatsPerMinute != nullptr)

  871.                 {

  872.                     double beatsPerMinuteValue = -1.0;

  873. 

  874.                     /**/ if (beatsPerMinute->type == fURIs.atomDouble)

  875.                         beatsPerMinuteValue = ((LV2_Atom_Double*)beatsPerMinute)->body;

  876.                     else if (beatsPerMinute->type == fURIs.atomFloat)

  877.                         beatsPerMinuteValue = ((LV2_Atom_Float*)beatsPerMinute)->body;

  878.                     else if (beatsPerMinute->type == fURIs.atomInt)

  879.                         beatsPerMinuteValue = static_cast<double>(((LV2_Atom_Int*)beatsPerMinute)->body);

  880.                     else if (beatsPerMinute->type == fURIs.atomLong)

  881.                         beatsPerMinuteValue = static_cast<double>(((LV2_Atom_Long*)beatsPerMinute)->body);

  882.                     else

  883.                         carla_stderr("Unknown lv2 beatsPerMinute value type");

  884. 

  885.                     if (beatsPerMinuteValue >= 12.0 && beatsPerMinuteValue <= 999.0)

  886.                     {

  887.                         fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute = beatsPerMinuteValue;

  888. 

  889.                         if (carla_isNotZero(fLastPositionData.speed))

  890.                             fTimeInfo.bbt.beatsPerMinute *= std::abs(fLastPositionData.speed);

  891.                     }

  892.                     else

  893.                     {

  894.                         carla_stderr("Invalid lv2 beatsPerMinute value");

  895.                     }

  896.                 }

  897. 

  898.                 if (frame != nullptr)

  899.                 {

  900.                     int64_t frameValue = -1;

  901. 

  902.                     /**/ if (frame->type == fURIs.atomDouble)

  903.                         frameValue = static_cast<int64_t>(((LV2_Atom_Double*)frame)->body);

  904.                     else if (frame->type == fURIs.atomFloat)

  905.                         frameValue = static_cast<int64_t>(((LV2_Atom_Float*)frame)->body);

  906.                     else if (frame->type == fURIs.atomInt)

  907.                         frameValue = ((LV2_Atom_Int*)frame)->body;

  908.                     else if (frame->type == fURIs.atomLong)

  909.                         frameValue = ((LV2_Atom_Long*)frame)->body;

  910.                     else

  911.                         carla_stderr("Unknown lv2 frame value type");

  912. 

  913.                     if (frameValue >= 0)

  914.                         fTimeInfo.frame = fLastPositionData.frame = static_cast<uint64_t>(frameValue);

  915.                     else

  916.                         carla_stderr("Invalid lv2 frame value");

  917.                 }

  918. 

  919.                 fTimeInfo.bbt.barStartTick = static_cast<double>(fTimeInfo.bbt.ticksPerBeat) *

  920.                                              static_cast<double>(fTimeInfo.bbt.beatsPerBar) *

  921.                                              (fTimeInfo.bbt.bar-1);

  922. 

  923.                 fTimeInfo.bbt.valid = (fLastPositionData.beatsPerMinute > 0.0 &&

  924.                                        fLastPositionData.beatUnit > 0 &&

  925.                                        fLastPositionData.beatsPerBar > 0.0f);

  926.             }

  927.         }

  928. 

  929.         // Check for updated parameters

  930.         float curValue;

  931. 

  932.         for (uint32_t i=0; i < fPorts.numParams; ++i)

  933.         {

  934.             if (fPorts.paramsOut[i])

  935.                 continue;

  936. 

  937.             CARLA_SAFE_ASSERT_CONTINUE(fPorts.paramsPtr[i] != nullptr)

  938. 

  939.             curValue = *fPorts.paramsPtr[i];

  940. 

  941.             if (carla_isEqual(fPorts.paramsLast[i], curValue))

  942.                 continue;

  943. 

  944.             fPorts.paramsLast[i] = curValue;

  945.             handleParameterValueChanged(i, curValue);

  946.         }

  947. 

  948.         if (frames == 0)

  949.             return false;

  950. 

  951.         // init midi out data

  952.         if (fPorts.numMidiOuts > 0 || fPorts.hasUI)

  953.         {

  954.             for (uint32_t i=0; i<fPorts.numMidiOuts; ++i)

  955.             {

  956.                 LV2_Atom_Sequence* const seq(fPorts.eventsOut[i]);

  957.                 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);

  958. 

  959.                 fPorts.eventsOutData[i].capacity = seq->atom.size;

  960.                 fPorts.eventsOutData[i].offset   = 0;

  961. 

  962.                 seq->atom.size = sizeof(LV2_Atom_Sequence_Body);

  963.                 seq->atom.type = fURIs.atomSequence;

  964.                 seq->body.unit = 0;

  965.                 seq->body.pad  = 0;

  966.             }

  967.         }

  968. 

  969.         return true;

  970.     }

  971. 

  972.     void lv2_post_run(const uint32_t frames)

  973.     {

  974.         // update timePos for next callback

  975. 

  976.         if (carla_isZero(fLastPositionData.speed))

  977.             return;

  978. 

  979.         if (fLastPositionData.speed > 0.0)

  980.         {

  981.             // playing forwards

  982.             fLastPositionData.frame += frames;

  983.         }

  984.         else

  985.         {

  986.             // playing backwards

  987.             if (frames >= fLastPositionData.frame)

  988.                 fLastPositionData.frame = 0;

  989.             else

  990.                 fLastPositionData.frame -= frames;

  991.         }

  992. 

  993.         fTimeInfo.frame = fLastPositionData.frame;

  994. 

  995.         if (fTimeInfo.bbt.valid)

  996.         {

  997.             const double beatsPerMinute = fLastPositionData.beatsPerMinute * fLastPositionData.speed;

  998.             const double framesPerBeat  = 60.0 * fSampleRate / beatsPerMinute;

  999.             const double addedBarBeats  = double(frames) / framesPerBeat;

  1000. 

  1001.             if (fLastPositionData.barBeat >= 0.0f)

  1002.             {

  1003.                 fLastPositionData.barBeat = std::fmod(fLastPositionData.barBeat+static_cast<float>(addedBarBeats),

  1004.                                                       fLastPositionData.beatsPerBar);

  1005. 

  1006.                 const double rest  = std::fmod(fLastPositionData.barBeat, 1.0f);

  1007.                 fTimeInfo.bbt.beat = static_cast<int32_t>(static_cast<double>(fLastPositionData.barBeat)-rest+1.0);

  1008.                 fTimeInfo.bbt.tick = static_cast<int32_t>(rest*fTimeInfo.bbt.ticksPerBeat+0.5);

  1009. 

  1010.                 if (fLastPositionData.bar_f >= 0.0f)

  1011.                 {

  1012.                     fLastPositionData.bar_f += std::floor((fLastPositionData.barBeat+static_cast<float>(addedBarBeats))/

  1013.                                                             fLastPositionData.beatsPerBar);

  1014. 

  1015.                     if (fLastPositionData.bar_f <= 0.0f)

  1016.                     {

  1017.                         fLastPositionData.bar   = 0;

  1018.                         fLastPositionData.bar_f = 0.0f;

  1019.                     }

  1020.                     else

  1021.                     {

  1022.                         fLastPositionData.bar = static_cast<int32_t>(fLastPositionData.bar_f+0.5f);

  1023.                     }

  1024. 

  1025.                     fTimeInfo.bbt.bar = fLastPositionData.bar + 1;

  1026. 

  1027.                     fTimeInfo.bbt.barStartTick = static_cast<double>(fTimeInfo.bbt.ticksPerBeat) *

  1028.                                                  static_cast<double>(fTimeInfo.bbt.beatsPerBar) *

  1029.                                                  (fTimeInfo.bbt.bar-1);

  1030.                 }

  1031.             }

  1032.         }

  1033.     }

  1034. 

  1035.     // ----------------------------------------------------------------------------------------------------------------

  1036. 

  1037.     uint32_t lv2_get_options(LV2_Options_Option* const /*options*/) const

  1038.     {

  1039.         // currently unused

  1040.         return LV2_OPTIONS_SUCCESS;

  1041.     }

  1042. 

  1043.     uint32_t lv2_set_options(const LV2_Options_Option* const options)

  1044.     {

  1045.         for (int i=0; options[i].key != 0; ++i)

  1046.         {

  1047.             if (options[i].key == fUridMap->map(fUridMap->handle, LV2_BUF_SIZE__nominalBlockLength))

  1048.             {

  1049.                 if (options[i].type == fURIs.atomInt)

  1050.                 {

  1051.                     const int32_t value(*(const int32_t*)options[i].value);

  1052.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  1053. 

  1054.                     const uint32_t newBufferSize = static_cast<uint32_t>(value);

  1055. 

  1056.                     if (fBufferSize != newBufferSize)

  1057.                     {

  1058.                         fBufferSize = newBufferSize;

  1059.                         handleBufferSizeChanged(newBufferSize);

  1060.                     }

  1061.                 }

  1062.                 else

  1063.                 {

  1064.                     carla_stderr("Host changed nominalBlockLength but with wrong value type");

  1065.                 }

  1066.             }

  1067.             else if (options[i].key == fUridMap->map(fUridMap->handle, LV2_BUF_SIZE__maxBlockLength) && ! fUsingNominal)

  1068.             {

  1069.                 if (options[i].type == fURIs.atomInt)

  1070.                 {

  1071.                     const int32_t value(*(const int32_t*)options[i].value);

  1072.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  1073. 

  1074.                     const uint32_t newBufferSize = static_cast<uint32_t>(value);

  1075. 

  1076.                     if (fBufferSize != newBufferSize)

  1077.                     {

  1078.                         fBufferSize = newBufferSize;

  1079.                         handleBufferSizeChanged(newBufferSize);

  1080.                     }

  1081.                 }

  1082.                 else

  1083.                 {

  1084.                     carla_stderr("Host changed maxBlockLength but with wrong value type");

  1085.                 }

  1086.             }

  1087.             else if (options[i].key == fUridMap->map(fUridMap->handle, LV2_PARAMETERS__sampleRate))

  1088.             {

  1089.                 if (options[i].type == fURIs.atomFloat)

  1090.                 {

  1091.                     const double value(*(const float*)options[i].value);

  1092.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0.0);

  1093. 

  1094.                     if (carla_isNotEqual(fSampleRate, value))

  1095.                     {

  1096.                         fSampleRate = value;

  1097.                         handleSampleRateChanged(value);

  1098.                     }

  1099.                 }

  1100.                 else

  1101.                 {

  1102.                     carla_stderr("Host changed sampleRate but with wrong value type");

  1103.                 }

  1104.             }

  1105.         }

  1106. 

  1107.         return LV2_OPTIONS_SUCCESS;

  1108.     }

  1109. 

  1110.     // ----------------------------------------------------------------------------------------------------------------

  1111. 

  1112.     int lv2ui_idle() const

  1113.     {

  1114.         if (! fUI.isVisible)

  1115.             return 1;

  1116. 

  1117.         handleUiRun();

  1118.         return 0;

  1119.     }

  1120. 

  1121.     int lv2ui_show()

  1122.     {

  1123.         handleUiShow();

  1124.         return 0;

  1125.     }

  1126. 

  1127.     int lv2ui_hide()

  1128.     {

  1129.         handleUiHide();

  1130.         return 0;

  1131.     }

  1132. 

  1133.     void lv2ui_cleanup()

  1134.     {

  1135.         if (fUI.isVisible)

  1136.             handleUiHide();

  1137. 

  1138.         fUI.host = nullptr;

  1139.         fUI.writeFunction = nullptr;

  1140.         fUI.controller = nullptr;

  1141.     }

  1142. 

  1143.     // ----------------------------------------------------------------------------------------------------------------

  1144. 

  1145. protected:

  1146.     virtual void handleUiRun() const = 0;

  1147.     virtual void handleUiShow() = 0;

  1148.     virtual void handleUiHide() = 0;

  1149. 

  1150.     virtual void handleParameterValueChanged(const uint32_t index, const float value) = 0;

  1151.     virtual void handleBufferSizeChanged(const uint32_t bufferSize) = 0;

  1152.     virtual void handleSampleRateChanged(const double sampleRate) = 0;

  1153. 

  1154.     void resetTimeInfo() noexcept

  1155.     {

  1156.         clearTimeData();

  1157. 

  1158.         // hosts may not send all values, resulting on some invalid data

  1159.         fTimeInfo.bbt.bar   = 1;

  1160.         fTimeInfo.bbt.beat  = 1;

  1161.         fTimeInfo.bbt.beatsPerBar    = 4;

  1162.         fTimeInfo.bbt.beatType       = 4;

  1163.         fTimeInfo.bbt.ticksPerBeat   = fLastPositionData.ticksPerBeat   = 960.0;

  1164.         fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute = 120.0;

  1165.     }

  1166. 

  1167.     // LV2 host data

  1168.     bool     fIsActive : 1;

  1169.     bool     fIsOffline : 1;

  1170.     bool     fUsingNominal : 1;

  1171.     uint32_t fBufferSize;

  1172.     double   fSampleRate;

  1173. 

  1174.     // LV2 host features

  1175.     const LV2_URID_Map* fUridMap;

  1176.     const LV2_Worker_Schedule* fWorker;

  1177. 

  1178.     // Time info stuff

  1179.     TimeInfoStruct fTimeInfo;

  1180. 

  1181.     struct Lv2PositionData {

  1182.         int32_t  bar;

  1183.         float    bar_f;

  1184.         float    barBeat;

  1185.         uint32_t beatUnit;

  1186.         float    beatsPerBar;

  1187.         double   beatsPerMinute;

  1188.         uint64_t frame;

  1189.         double   speed;

  1190.         double   ticksPerBeat;

  1191. 

  1192.         Lv2PositionData()

  1193.             : bar(-1),

  1194.               bar_f(-1.0f),

  1195.               barBeat(-1.0f),

  1196.               beatUnit(0),

  1197.               beatsPerBar(0.0f),

  1198.               beatsPerMinute(-1.0),

  1199.               frame(0),

  1200.               speed(0.0),

  1201.               ticksPerBeat(-1.0) {}

  1202. 

  1203.         void clear()

  1204.         {

  1205.             bar = -1;

  1206.             bar_f = -1.0f;

  1207.             barBeat = -1.0f;

  1208.             beatUnit = 0;

  1209.             beatsPerBar = 0.0f;

  1210.             beatsPerMinute = -1.0;

  1211.             frame = 0;

  1212.             speed = 0.0;

  1213.             ticksPerBeat = -1.0;

  1214.         }

  1215. 

  1216.     } fLastPositionData;

  1217. 

  1218.     // Port stuff

  1219.     struct Ports {

  1220.         // need to save current state

  1221.         struct EventsOutData {

  1222.             uint32_t capacity;

  1223.             uint32_t offset;

  1224. 

  1225.             EventsOutData()

  1226.                 : capacity(0),

  1227.                   offset(0) {}

  1228.         };

  1229. 

  1230.         // store port info

  1231.         uint32_t indexOffset;

  1232.         uint32_t numAudioIns;

  1233.         uint32_t numAudioOuts;

  1234.         uint32_t numMidiIns;

  1235.         uint32_t numMidiOuts;

  1236.         uint32_t numParams;

  1237.         bool hasUI;

  1238.         bool usesTime;

  1239. 

  1240.         // port buffers

  1241.         const LV2_Atom_Sequence** eventsIn;

  1242.         /* */ LV2_Atom_Sequence** eventsOut;

  1243.         /* */ EventsOutData*      eventsOutData;

  1244.         const float** audioIns;

  1245.         /* */ float** audioOuts;

  1246.         /* */ float*  freewheel;

  1247. 

  1248.         // cached parameter values

  1249.         float*  paramsLast;

  1250.         float** paramsPtr;

  1251.         bool*   paramsOut;

  1252. 

  1253.         Ports()

  1254.             : indexOffset(0),

  1255.               numAudioIns(0),

  1256.               numAudioOuts(0),

  1257.               numMidiIns(0),

  1258.               numMidiOuts(0),

  1259.               numParams(0),

  1260.               hasUI(false),

  1261.               usesTime(false),

  1262.               eventsIn(nullptr),

  1263.               eventsOut(nullptr),

  1264.               eventsOutData(nullptr),

  1265.               audioIns(nullptr),

  1266.               audioOuts(nullptr),

  1267.               freewheel(nullptr),

  1268.               paramsLast(nullptr),

  1269.               paramsPtr(nullptr),

  1270.               paramsOut(nullptr) {}

  1271. 

  1272.         ~Ports()

  1273.         {

  1274.             if (eventsIn != nullptr)

  1275.             {

  1276.                 delete[] eventsIn;

  1277.                 eventsIn = nullptr;

  1278.             }

  1279. 

  1280.             if (eventsOut != nullptr)

  1281.             {

  1282.                 delete[] eventsOut;

  1283.                 eventsOut = nullptr;

  1284.             }

  1285. 

  1286.             if (eventsOutData != nullptr)

  1287.             {

  1288.                 delete[] eventsOutData;

  1289.                 eventsOutData = nullptr;

  1290.             }

  1291. 

  1292.             if (audioIns != nullptr)

  1293.             {

  1294.                 delete[] audioIns;

  1295.                 audioIns = nullptr;

  1296.             }

  1297. 

  1298.             if (audioOuts != nullptr)

  1299.             {

  1300.                 delete[] audioOuts;

  1301.                 audioOuts = nullptr;

  1302.             }

  1303. 

  1304.             if (paramsLast != nullptr)

  1305.             {

  1306.                 delete[] paramsLast;

  1307.                 paramsLast = nullptr;

  1308.             }

  1309. 

  1310.             if (paramsPtr != nullptr)

  1311.             {

  1312.                 delete[] paramsPtr;

  1313.                 paramsPtr = nullptr;

  1314.             }

  1315. 

  1316.             if (paramsOut != nullptr)

  1317.             {

  1318.                 delete[] paramsOut;

  1319.                 paramsOut = nullptr;

  1320.             }

  1321.         }

  1322. 

  1323.         // NOTE: assumes num* has been filled by parent class

  1324.         void init()

  1325.         {

  1326.             if (numMidiIns > 0)

  1327.             {

  1328.                 eventsIn = new const LV2_Atom_Sequence*[numMidiIns];

  1329. 

  1330.                 for (uint32_t i=0; i < numMidiIns; ++i)

  1331.                     eventsIn[i] = nullptr;

  1332.             }

  1333.             else if (usesTime || hasUI)

  1334.             {

  1335.                 eventsIn = new const LV2_Atom_Sequence*[1];

  1336.                 eventsIn[0] = nullptr;

  1337.             }

  1338. 

  1339.             if (numMidiOuts > 0)

  1340.             {

  1341.                 eventsOut = new LV2_Atom_Sequence*[numMidiOuts];

  1342.                 eventsOutData = new EventsOutData[numMidiOuts];

  1343. 

  1344.                 for (uint32_t i=0; i < numMidiOuts; ++i)

  1345.                     eventsOut[i] = nullptr;

  1346.             }

  1347.             else if (hasUI)

  1348.             {

  1349.                 eventsOut = new LV2_Atom_Sequence*[1];

  1350.                 eventsOut[0] = nullptr;

  1351.             }

  1352. 

  1353.             if (numAudioIns > 0)

  1354.             {

  1355.                 audioIns = new const float*[numAudioIns];

  1356. 

  1357.                 for (uint32_t i=0; i < numAudioIns; ++i)

  1358.                     audioIns[i] = nullptr;

  1359.             }

  1360. 

  1361.             if (numAudioOuts > 0)

  1362.             {

  1363.                 audioOuts = new float*[numAudioOuts];

  1364. 

  1365.                 for (uint32_t i=0; i < numAudioOuts; ++i)

  1366.                     audioOuts[i] = nullptr;

  1367.             }

  1368. 

  1369.             if (numParams > 0)

  1370.             {

  1371.                 paramsLast = new float[numParams];

  1372.                 paramsPtr  = new float*[numParams];

  1373.                 paramsOut  = new bool[numParams];

  1374. 

  1375.                 carla_zeroFloats(paramsLast, numParams);

  1376.                 carla_zeroPointers(paramsPtr, numParams);

  1377.                 carla_zeroStructs(paramsOut, numParams);

  1378. 

  1379.                 // NOTE: need to be filled in by the parent class

  1380.             }

  1381. 

  1382.             indexOffset  = numAudioIns + numAudioOuts;

  1383.             // 1 event port for time or ui if no midi input is used

  1384.             indexOffset += numMidiIns > 0 ? numMidiIns : ((usesTime || hasUI) ? 1 : 0);

  1385.             // 1 event port for ui if no midi output is used

  1386.             indexOffset += numMidiOuts > 0 ? numMidiOuts : (hasUI ? 1 : 0);

  1387.             // 1 extra for freewheel port

  1388.             indexOffset += 1;

  1389.         }

  1390. 

  1391.         void connectPort(const uint32_t port, void* const dataLocation)

  1392.         {

  1393.             uint32_t index = 0;

  1394. 

  1395.             if (numMidiIns > 0 || usesTime || hasUI)

  1396.             {

  1397.                 if (port == index++)

  1398.                 {

  1399.                     eventsIn[0] = (LV2_Atom_Sequence*)dataLocation;

  1400.                     return;

  1401.                 }

  1402.             }

  1403. 

  1404.             for (uint32_t i=1; i < numMidiIns; ++i)

  1405.             {

  1406.                 if (port == index++)

  1407.                 {

  1408.                     eventsIn[i] = (LV2_Atom_Sequence*)dataLocation;

  1409.                     return;

  1410.                 }

  1411.             }

  1412. 

  1413.             if (numMidiOuts > 0 || hasUI)

  1414.             {

  1415.                 if (port == index++)

  1416.                 {

  1417.                     eventsOut[0] = (LV2_Atom_Sequence*)dataLocation;

  1418.                     return;

  1419.                 }

  1420.             }

  1421. 

  1422.             for (uint32_t i=1; i < numMidiOuts; ++i)

  1423.             {

  1424.                 if (port == index++)

  1425.                 {

  1426.                     eventsOut[i] = (LV2_Atom_Sequence*)dataLocation;

  1427.                     return;

  1428.                 }

  1429.             }

  1430. 

  1431.             if (port == index++)

  1432.             {

  1433.                 freewheel = (float*)dataLocation;

  1434.                 return;

  1435.             }

  1436. 

  1437.             for (uint32_t i=0; i < numAudioIns; ++i)

  1438.             {

  1439.                 if (port == index++)

  1440.                 {

  1441.                     audioIns[i] = (float*)dataLocation;

  1442.                     return;

  1443.                 }

  1444.             }

  1445. 

  1446.             for (uint32_t i=0; i < numAudioOuts; ++i)

  1447.             {

  1448.                 if (port == index++)

  1449.                 {

  1450.                     audioOuts[i] = (float*)dataLocation;

  1451.                     return;

  1452.                 }

  1453.             }

  1454. 

  1455.             for (uint32_t i=0; i < numParams; ++i)

  1456.             {

  1457.                 if (port == index++)

  1458.                 {

  1459.                     paramsPtr[i] = (float*)dataLocation;

  1460.                     return;

  1461.                 }

  1462.             }

  1463.         }

  1464. 

  1465.         CARLA_DECLARE_NON_COPY_STRUCT(Ports);

  1466.     } fPorts;

  1467. 

  1468.     // Rest of host<->plugin support

  1469.     struct URIDs {

  1470.         LV2_URID atomBlank;

  1471.         LV2_URID atomObject;

  1472.         LV2_URID atomDouble;

  1473.         LV2_URID atomFloat;

  1474.         LV2_URID atomInt;

  1475.         LV2_URID atomLong;

  1476.         LV2_URID atomSequence;

  1477.         LV2_URID atomString;

  1478.         LV2_URID midiEvent;

  1479.         LV2_URID timePos;

  1480.         LV2_URID timeBar;

  1481.         LV2_URID timeBarBeat;

  1482.         LV2_URID timeBeatsPerBar;

  1483.         LV2_URID timeBeatsPerMinute;

  1484.         LV2_URID timeBeatUnit;

  1485.         LV2_URID timeFrame;

  1486.         LV2_URID timeSpeed;

  1487.         LV2_URID timeTicksPerBeat;

  1488.         LV2_URID uiEvents;

  1489. 

  1490.         URIDs()

  1491.             : atomBlank(0),

  1492.               atomObject(0),

  1493.               atomDouble(0),

  1494.               atomFloat(0),

  1495.               atomInt(0),

  1496.               atomLong(0),

  1497.               atomSequence(0),

  1498.               atomString(0),

  1499.               midiEvent(0),

  1500.               timePos(0),

  1501.               timeBar(0),

  1502.               timeBarBeat(0),

  1503.               timeBeatsPerBar(0),

  1504.               timeBeatsPerMinute(0),

  1505.               timeBeatUnit(0),

  1506.               timeFrame(0),

  1507.               timeSpeed(0),

  1508.               timeTicksPerBeat(0),

  1509.               uiEvents(0) {}

  1510. 

  1511.         void map(const LV2_URID_Map* const uridMap)

  1512.         {

  1513.             atomBlank          = uridMap->map(uridMap->handle, LV2_ATOM__Blank);

  1514.             atomObject         = uridMap->map(uridMap->handle, LV2_ATOM__Object);

  1515.             atomDouble         = uridMap->map(uridMap->handle, LV2_ATOM__Double);

  1516.             atomFloat          = uridMap->map(uridMap->handle, LV2_ATOM__Float);

  1517.             atomInt            = uridMap->map(uridMap->handle, LV2_ATOM__Int);

  1518.             atomLong           = uridMap->map(uridMap->handle, LV2_ATOM__Long);

  1519.             atomSequence       = uridMap->map(uridMap->handle, LV2_ATOM__Sequence);

  1520.             atomString         = uridMap->map(uridMap->handle, LV2_ATOM__String);

  1521.             midiEvent          = uridMap->map(uridMap->handle, LV2_MIDI__MidiEvent);

  1522.             timePos            = uridMap->map(uridMap->handle, LV2_TIME__Position);

  1523.             timeBar            = uridMap->map(uridMap->handle, LV2_TIME__bar);

  1524.             timeBarBeat        = uridMap->map(uridMap->handle, LV2_TIME__barBeat);

  1525.             timeBeatUnit       = uridMap->map(uridMap->handle, LV2_TIME__beatUnit);

  1526.             timeFrame          = uridMap->map(uridMap->handle, LV2_TIME__frame);

  1527.             timeSpeed          = uridMap->map(uridMap->handle, LV2_TIME__speed);

  1528.             timeBeatsPerBar    = uridMap->map(uridMap->handle, LV2_TIME__beatsPerBar);

  1529.             timeBeatsPerMinute = uridMap->map(uridMap->handle, LV2_TIME__beatsPerMinute);

  1530.             timeTicksPerBeat   = uridMap->map(uridMap->handle, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat);

  1531.             uiEvents           = uridMap->map(uridMap->handle, "urn:carla:transmitEv");

  1532.         }

  1533.     } fURIs;

  1534. 

  1535.     struct UI {

  1536.         const LV2_External_UI_Host* host;

  1537.         LV2UI_Write_Function writeFunction;

  1538.         LV2UI_Controller controller;

  1539.         bool isVisible;

  1540. 

  1541.         UI()

  1542.             : host(nullptr),

  1543.               writeFunction(nullptr),

  1544.               controller(nullptr),

  1545.               isVisible(false) {}

  1546.     } fUI;

  1547. 

  1548. private:

  1549.     // ----------------------------------------------------------------------------------------------------------------

  1550. 

  1551.     #define handlePtr ((Lv2PluginBaseClass*)handle)

  1552. 

  1553.     static void extui_run(LV2_External_UI_Widget_Compat* handle)

  1554.     {

  1555.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  1556. 

  1557.         handlePtr->handleUiRun();

  1558.     }

  1559. 

  1560.     static void extui_show(LV2_External_UI_Widget_Compat* handle)

  1561.     {

  1562.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  1563.         carla_debug("extui_show(%p)", handle);

  1564. 

  1565.         handlePtr->handleUiShow();

  1566.     }

  1567. 

  1568.     static void extui_hide(LV2_External_UI_Widget_Compat* handle)

  1569.     {

  1570.         CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);

  1571.         carla_debug("extui_hide(%p)", handle);

  1572. 

  1573.         handlePtr->handleUiHide();

  1574.     }

  1575. 

  1576.     #undef handlePtr

  1577. 

  1578.     // ----------------------------------------------------------------------------------------------------------------

  1579. 

  1580.     void clearTimeData() noexcept;

  1581. 

  1582.     // ----------------------------------------------------------------------------------------------------------------

  1583. 

  1584.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2PluginBaseClass)

  1585. };

  1586. 

  1587. // --------------------------------------------------------------------------------------------------------------------

  1588. // Create new RDF object (using lilv)

  1589. 

  1590. static inline

  1591. const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI uri, const bool loadPresets)

  1592. {

  1593.     CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', nullptr);

  1594. 

  1595.     Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());

  1596. 

  1597.     const LilvPlugin* const cPlugin(lv2World.getPluginFromURI(uri));

  1598.     CARLA_SAFE_ASSERT_RETURN(cPlugin != nullptr, nullptr);

  1599. 

  1600.     Lilv::Plugin lilvPlugin(cPlugin);

  1601.     LV2_RDF_Descriptor* const rdfDescriptor(new LV2_RDF_Descriptor());

  1602. 

  1603.     // ----------------------------------------------------------------------------------------------------------------

  1604.     // Set Plugin Type

  1605.     {

  1606.         Lilv::Nodes typeNodes(lilvPlugin.get_value(lv2World.rdf_type));

  1607. 

  1608.         if (typeNodes.size() > 0)

  1609.         {

  1610.             if (typeNodes.contains(lv2World.class_allpass))

  1611.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_ALLPASS;

  1612.             if (typeNodes.contains(lv2World.class_amplifier))

  1613.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_AMPLIFIER;

  1614.             if (typeNodes.contains(lv2World.class_analyzer))

  1615.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_ANALYSER;

  1616.             if (typeNodes.contains(lv2World.class_bandpass))

  1617.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_BANDPASS;

  1618.             if (typeNodes.contains(lv2World.class_chorus))

  1619.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_CHORUS;

  1620.             if (typeNodes.contains(lv2World.class_comb))

  1621.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_COMB;

  1622.             if (typeNodes.contains(lv2World.class_compressor))

  1623.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_COMPRESSOR;

  1624.             if (typeNodes.contains(lv2World.class_constant))

  1625.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_CONSTANT;

  1626.             if (typeNodes.contains(lv2World.class_converter))

  1627.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_CONVERTER;

  1628.             if (typeNodes.contains(lv2World.class_delay))

  1629.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_DELAY;

  1630.             if (typeNodes.contains(lv2World.class_distortion))

  1631.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_DISTORTION;

  1632.             if (typeNodes.contains(lv2World.class_dynamics))

  1633.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_DYNAMICS;

  1634.             if (typeNodes.contains(lv2World.class_eq))

  1635.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_EQ;

  1636.             if (typeNodes.contains(lv2World.class_envelope))

  1637.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_ENVELOPE;

  1638.             if (typeNodes.contains(lv2World.class_expander))

  1639.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_EXPANDER;

  1640.             if (typeNodes.contains(lv2World.class_filter))

  1641.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_FILTER;

  1642.             if (typeNodes.contains(lv2World.class_flanger))

  1643.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_FLANGER;

  1644.             if (typeNodes.contains(lv2World.class_function))

  1645.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_FUNCTION;

  1646.             if (typeNodes.contains(lv2World.class_gate))

  1647.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_GATE;

  1648.             if (typeNodes.contains(lv2World.class_generator))

  1649.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_GENERATOR;

  1650.             if (typeNodes.contains(lv2World.class_highpass))

  1651.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_HIGHPASS;

  1652.             if (typeNodes.contains(lv2World.class_instrument))

  1653.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_INSTRUMENT;

  1654.             if (typeNodes.contains(lv2World.class_limiter))

  1655.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_LIMITER;

  1656.             if (typeNodes.contains(lv2World.class_lowpass))

  1657.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_LOWPASS;

  1658.             if (typeNodes.contains(lv2World.class_mixer))

  1659.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_MIXER;

  1660.             if (typeNodes.contains(lv2World.class_modulator))

  1661.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_MODULATOR;

  1662.             if (typeNodes.contains(lv2World.class_multiEQ))

  1663.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_MULTI_EQ;

  1664.             if (typeNodes.contains(lv2World.class_oscillator))

  1665.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_OSCILLATOR;

  1666.             if (typeNodes.contains(lv2World.class_paraEQ))

  1667.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_PARA_EQ;

  1668.             if (typeNodes.contains(lv2World.class_phaser))

  1669.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_PHASER;

  1670.             if (typeNodes.contains(lv2World.class_pitch))

  1671.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_PITCH;

  1672.             if (typeNodes.contains(lv2World.class_reverb))

  1673.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_REVERB;

  1674.             if (typeNodes.contains(lv2World.class_simulator))

  1675.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_SIMULATOR;

  1676.             if (typeNodes.contains(lv2World.class_spatial))

  1677.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_SPATIAL;

  1678.             if (typeNodes.contains(lv2World.class_spectral))

  1679.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_SPECTRAL;

  1680.             if (typeNodes.contains(lv2World.class_utility))

  1681.                 rdfDescriptor->Type[1] |= LV2_PLUGIN_UTILITY;

  1682.             if (typeNodes.contains(lv2World.class_waveshaper))

  1683.                 rdfDescriptor->Type[0] |= LV2_PLUGIN_WAVESHAPER;

  1684.         }

  1685. 

  1686.         lilv_nodes_free(const_cast<LilvNodes*>(typeNodes.me));

  1687.     }

  1688. 

  1689.     // ----------------------------------------------------------------------------------------------------------------

  1690.     // Set Plugin Information

  1691.     {

  1692.         rdfDescriptor->URI = carla_strdup(uri);

  1693. 

  1694.         if (LilvNode* const nameNode = lilv_plugin_get_name(lilvPlugin.me))

  1695.         {

  1696.             if (const char* const name = lilv_node_as_string(nameNode))

  1697.                 rdfDescriptor->Name = carla_strdup(name);

  1698.             lilv_node_free(nameNode);

  1699.         }

  1700. 

  1701.         if (const char* const author = lilvPlugin.get_author_name().as_string())

  1702.             rdfDescriptor->Author = carla_strdup(author);

  1703. 

  1704.         if (const char* const binary = lilvPlugin.get_library_uri().as_string())

  1705.             rdfDescriptor->Binary = carla_strdup_free(lilv_file_uri_parse(binary, nullptr));

  1706. 

  1707.         if (const char* const bundle = lilvPlugin.get_bundle_uri().as_string())

  1708.             rdfDescriptor->Bundle = carla_strdup_free(lilv_file_uri_parse(bundle, nullptr));

  1709. 

  1710.         Lilv::Nodes licenseNodes(lilvPlugin.get_value(lv2World.doap_license));

  1711. 

  1712.         if (licenseNodes.size() > 0)

  1713.         {

  1714.             if (const char* const license = licenseNodes.get_first().as_string())

  1715.                 rdfDescriptor->License = carla_strdup(license);

  1716.         }

  1717. 

  1718.         lilv_nodes_free(const_cast<LilvNodes*>(licenseNodes.me));

  1719.     }

  1720. 

  1721.     // ----------------------------------------------------------------------------------------------------------------

  1722.     // Set Plugin UniqueID

  1723.     {

  1724.         Lilv::Nodes replaceNodes(lilvPlugin.get_value(lv2World.dct_replaces));

  1725. 

  1726.         if (replaceNodes.size() > 0)

  1727.         {

  1728.             Lilv::Node replaceNode(replaceNodes.get_first());

  1729. 

  1730.             if (replaceNode.is_uri())

  1731.             {

  1732. #ifdef USE_QT

  1733.                 const QString replaceURI(replaceNode.as_uri());

  1734. 

  1735.                 if (replaceURI.startsWith("urn:"))

  1736.                 {

  1737.                     const QString replaceId(replaceURI.split(":").last());

  1738. 

  1739.                     bool ok;

  1740.                     const ulong uniqueId(replaceId.toULong(&ok));

  1741. 

  1742.                     if (ok && uniqueId != 0)

  1743.                         rdfDescriptor->UniqueID = uniqueId;

  1744.                 }

  1745. #else

  1746.                 const water::String replaceURI(replaceNode.as_uri());

  1747. 

  1748.                 if (replaceURI.startsWith("urn:"))

  1749.                 {

  1750.                     const int uniqueId(replaceURI.getTrailingIntValue());

  1751. 

  1752.                     if (uniqueId > 0)

  1753.                         rdfDescriptor->UniqueID = static_cast<ulong>(uniqueId);

  1754.                 }

  1755. #endif

  1756.             }

  1757.         }

  1758. 

  1759.         lilv_nodes_free(const_cast<LilvNodes*>(replaceNodes.me));

  1760.     }

  1761. 

  1762.     // ----------------------------------------------------------------------------------------------------------------

  1763.     // Set Plugin Ports

  1764. 

  1765.     if (const uint numPorts = lilvPlugin.get_num_ports())

  1766.     {

  1767.         rdfDescriptor->PortCount = numPorts;

  1768.         rdfDescriptor->Ports = new LV2_RDF_Port[numPorts];

  1769. 

  1770.         for (uint i = 0; i < numPorts; ++i)

  1771.         {

  1772.             Lilv::Port lilvPort(lilvPlugin.get_port_by_index(i));

  1773.             LV2_RDF_Port* const rdfPort(&rdfDescriptor->Ports[i]);

  1774. 

  1775.             // --------------------------------------------------------------------------------------------------------

  1776.             // Set Port Information

  1777.             {

  1778.                 if (LilvNode* const nameNode = lilv_port_get_name(lilvPlugin.me, lilvPort.me))

  1779.                 {

  1780.                     if (const char* const name = lilv_node_as_string(nameNode))

  1781.                         rdfPort->Name = carla_strdup(name);

  1782.                     lilv_node_free(nameNode);

  1783.                 }

  1784. 

  1785.                 if (const char* const symbol = lilv_node_as_string(lilvPort.get_symbol()))

  1786.                     rdfPort->Symbol = carla_strdup(symbol);

  1787.             }

  1788. 

  1789.             // --------------------------------------------------------------------------------------------------------

  1790.             // Set Port Mode and Type

  1791.             {

  1792.                 // Input or Output

  1793.                 /**/ if (lilvPort.is_a(lv2World.port_input))

  1794.                     rdfPort->Types |= LV2_PORT_INPUT;

  1795.                 else if (lilvPort.is_a(lv2World.port_output))

  1796.                     rdfPort->Types |= LV2_PORT_OUTPUT;

  1797.                 else

  1798.                     carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is not input or output", uri, rdfPort->Name);

  1799. 

  1800.                 // Data Type

  1801.                 /**/ if (lilvPort.is_a(lv2World.port_control))

  1802.                 {

  1803.                     rdfPort->Types |= LV2_PORT_CONTROL;

  1804.                 }

  1805.                 else if (lilvPort.is_a(lv2World.port_audio))

  1806.                 {

  1807.                     rdfPort->Types |= LV2_PORT_AUDIO;

  1808.                 }

  1809.                 else if (lilvPort.is_a(lv2World.port_cv))

  1810.                 {

  1811.                     rdfPort->Types |= LV2_PORT_CV;

  1812.                 }

  1813.                 else if (lilvPort.is_a(lv2World.port_atom))

  1814.                 {

  1815.                     rdfPort->Types |= LV2_PORT_ATOM;

  1816. 

  1817.                     Lilv::Nodes bufferTypeNodes(lilvPort.get_value(lv2World.atom_bufferType));

  1818. 

  1819.                     for (LilvIter* it = lilv_nodes_begin(bufferTypeNodes.me); ! lilv_nodes_is_end(bufferTypeNodes.me, it); it = lilv_nodes_next(bufferTypeNodes.me, it))

  1820.                     {

  1821.                         const Lilv::Node node(lilv_nodes_get(bufferTypeNodes.me, it));

  1822.                         CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  1823. 

  1824.                         if (node.equals(lv2World.atom_sequence))

  1825.                             rdfPort->Types |= LV2_PORT_ATOM_SEQUENCE;

  1826.                         else

  1827.                             carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses an unknown atom buffer type '%s'", uri, rdfPort->Name, node.as_uri());

  1828.                     }

  1829. 

  1830.                     Lilv::Nodes supportNodes(lilvPort.get_value(lv2World.atom_supports));

  1831. 

  1832.                     for (LilvIter* it = lilv_nodes_begin(supportNodes.me); ! lilv_nodes_is_end(supportNodes.me, it); it = lilv_nodes_next(supportNodes.me, it))

  1833.                     {

  1834.                         const Lilv::Node node(lilv_nodes_get(supportNodes.me, it));

  1835.                         CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  1836. 

  1837.                         /**/ if (node.equals(lv2World.midi_event))

  1838.                             rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;

  1839. 

  1840.                         else if (node.equals(lv2World.patch_message))

  1841.                             rdfPort->Types |= LV2_PORT_DATA_PATCH_MESSAGE;

  1842. 

  1843.                         else if (node.equals(lv2World.time_position))

  1844.                             rdfPort->Types |= LV2_PORT_DATA_TIME_POSITION;

  1845. 

  1846. #if 0

  1847.                         // something new we don't support yet?

  1848.                         else if (std::strstr(node.as_uri(), "lv2plug.in/") != nullptr)

  1849.                             carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is of atom type but has unsupported data '%s'", uri, rdfPort->Name, node.as_uri());

  1850. #endif

  1851.                     }

  1852. 

  1853.                     lilv_nodes_free(const_cast<LilvNodes*>(bufferTypeNodes.me));

  1854.                     lilv_nodes_free(const_cast<LilvNodes*>(supportNodes.me));

  1855.                 }

  1856.                 else if (lilvPort.is_a(lv2World.port_event))

  1857.                 {

  1858.                     rdfPort->Types |= LV2_PORT_EVENT;

  1859.                     bool supported  = false;

  1860. 

  1861.                     if (lilvPort.supports_event(lv2World.midi_event))

  1862.                     {

  1863.                         rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;

  1864.                         supported = true;

  1865.                     }

  1866.                     if (lilvPort.supports_event(lv2World.patch_message))

  1867.                     {

  1868.                         rdfPort->Types |= LV2_PORT_DATA_PATCH_MESSAGE;

  1869.                         supported = true;

  1870.                     }

  1871.                     if (lilvPort.supports_event(lv2World.time_position))

  1872.                     {

  1873.                         rdfPort->Types |= LV2_PORT_DATA_TIME_POSITION;

  1874.                         supported = true;

  1875.                     }

  1876. 

  1877.                     if (! supported)

  1878.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is of event type but has unsupported data", uri, rdfPort->Name);

  1879.                 }

  1880.                 else if (lilvPort.is_a(lv2World.port_midi))

  1881.                 {

  1882.                     rdfPort->Types |= LV2_PORT_MIDI_LL;

  1883.                     rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;

  1884.                 }

  1885.                 else

  1886.                     carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is of unkown data type", uri, rdfPort->Name);

  1887.             }

  1888. 

  1889.             // --------------------------------------------------------------------------------------------------------

  1890.             // Set Port Properties

  1891.             {

  1892.                 if (lilvPort.has_property(lv2World.pprop_optional))

  1893.                     rdfPort->Properties |= LV2_PORT_OPTIONAL;

  1894.                 if (lilvPort.has_property(lv2World.pprop_enumeration))

  1895.                     rdfPort->Properties |= LV2_PORT_ENUMERATION;

  1896.                 if (lilvPort.has_property(lv2World.pprop_integer))

  1897.                     rdfPort->Properties |= LV2_PORT_INTEGER;

  1898.                 if (lilvPort.has_property(lv2World.pprop_sampleRate))

  1899.                     rdfPort->Properties |= LV2_PORT_SAMPLE_RATE;

  1900.                 if (lilvPort.has_property(lv2World.pprop_toggled))

  1901.                     rdfPort->Properties |= LV2_PORT_TOGGLED;

  1902. 

  1903.                 if (lilvPort.has_property(lv2World.pprop_artifacts))

  1904.                     rdfPort->Properties |= LV2_PORT_CAUSES_ARTIFACTS;

  1905.                 if (lilvPort.has_property(lv2World.pprop_continuousCV))

  1906.                     rdfPort->Properties |= LV2_PORT_CONTINUOUS_CV;

  1907.                 if (lilvPort.has_property(lv2World.pprop_discreteCV))

  1908.                     rdfPort->Properties |= LV2_PORT_DISCRETE_CV;

  1909.                 if (lilvPort.has_property(lv2World.pprop_expensive))

  1910.                     rdfPort->Properties |= LV2_PORT_EXPENSIVE;

  1911.                 if (lilvPort.has_property(lv2World.pprop_strictBounds))

  1912.                     rdfPort->Properties |= LV2_PORT_STRICT_BOUNDS;

  1913.                 if (lilvPort.has_property(lv2World.pprop_logarithmic))

  1914.                     rdfPort->Properties |= LV2_PORT_LOGARITHMIC;

  1915.                 if (lilvPort.has_property(lv2World.pprop_notAutomatic))

  1916.                     rdfPort->Properties |= LV2_PORT_NOT_AUTOMATIC;

  1917.                 if (lilvPort.has_property(lv2World.pprop_notOnGUI))

  1918.                     rdfPort->Properties |= LV2_PORT_NOT_ON_GUI;

  1919.                 if (lilvPort.has_property(lv2World.pprop_trigger))

  1920.                     rdfPort->Properties |= LV2_PORT_TRIGGER;

  1921.                 if (lilvPort.has_property(lv2World.pprop_nonAutomable))

  1922.                     rdfPort->Properties |= LV2_PORT_NON_AUTOMABLE;

  1923. 

  1924.                 if (lilvPort.has_property(lv2World.reportsLatency))

  1925.                     rdfPort->Designation = LV2_PORT_DESIGNATION_LATENCY;

  1926. 

  1927.                 // no port properties set, check if using old/invalid ones

  1928.                 if (rdfPort->Properties == 0x0)

  1929.                 {

  1930.                     const Lilv::Node oldPropArtifacts(lv2World.new_uri(NS_devp "causesArtifacts"));

  1931.                     const Lilv::Node oldPropContinuousCV(lv2World.new_uri(NS_devp "continuousCV"));

  1932.                     const Lilv::Node oldPropDiscreteCV(lv2World.new_uri(NS_devp "discreteCV"));

  1933.                     const Lilv::Node oldPropExpensive(lv2World.new_uri(NS_devp "expensive"));

  1934.                     const Lilv::Node oldPropStrictBounds(lv2World.new_uri(NS_devp "hasStrictBounds"));

  1935.                     const Lilv::Node oldPropLogarithmic(lv2World.new_uri(NS_devp "logarithmic"));

  1936.                     const Lilv::Node oldPropNotAutomatic(lv2World.new_uri(NS_devp "notAutomatic"));

  1937.                     const Lilv::Node oldPropNotOnGUI(lv2World.new_uri(NS_devp "notOnGUI"));

  1938.                     const Lilv::Node oldPropTrigger(lv2World.new_uri(NS_devp "trigger"));

  1939. 

  1940.                     if (lilvPort.has_property(oldPropArtifacts))

  1941.                     {

  1942.                         rdfPort->Properties |= LV2_PORT_CAUSES_ARTIFACTS;

  1943.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'causesArtifacts'", uri, rdfPort->Name);

  1944.                     }

  1945.                     if (lilvPort.has_property(oldPropContinuousCV))

  1946.                     {

  1947.                         rdfPort->Properties |= LV2_PORT_CONTINUOUS_CV;

  1948.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'continuousCV'", uri, rdfPort->Name);

  1949.                     }

  1950.                     if (lilvPort.has_property(oldPropDiscreteCV))

  1951.                     {

  1952.                         rdfPort->Properties |= LV2_PORT_DISCRETE_CV;

  1953.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'discreteCV'", uri, rdfPort->Name);

  1954.                     }

  1955.                     if (lilvPort.has_property(oldPropExpensive))

  1956.                     {

  1957.                         rdfPort->Properties |= LV2_PORT_EXPENSIVE;

  1958.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'expensive'", uri, rdfPort->Name);

  1959.                     }

  1960.                     if (lilvPort.has_property(oldPropStrictBounds))

  1961.                     {

  1962.                         rdfPort->Properties |= LV2_PORT_STRICT_BOUNDS;

  1963.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'hasStrictBounds'", uri, rdfPort->Name);

  1964.                     }

  1965.                     if (lilvPort.has_property(oldPropLogarithmic))

  1966.                     {

  1967.                         rdfPort->Properties |= LV2_PORT_LOGARITHMIC;

  1968.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'logarithmic'", uri, rdfPort->Name);

  1969.                     }

  1970.                     if (lilvPort.has_property(oldPropNotAutomatic))

  1971.                     {

  1972.                         rdfPort->Properties |= LV2_PORT_NOT_AUTOMATIC;

  1973.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'notAutomatic'", uri, rdfPort->Name);

  1974.                     }

  1975.                     if (lilvPort.has_property(oldPropNotOnGUI))

  1976.                     {

  1977.                         rdfPort->Properties |= LV2_PORT_NOT_ON_GUI;

  1978.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'notOnGUI'", uri, rdfPort->Name);

  1979.                     }

  1980.                     if (lilvPort.has_property(oldPropTrigger))

  1981.                     {

  1982.                         rdfPort->Properties |= LV2_PORT_TRIGGER;

  1983.                         carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'trigger'", uri, rdfPort->Name);

  1984.                     }

  1985.                 }

  1986.             }

  1987. 

  1988.             // --------------------------------------------------------------------------------------------------------

  1989.             // Set Port Designation

  1990.             {

  1991.                 if (LilvNode* const designationNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.designation.me))

  1992.                 {

  1993.                     if (const char* const designation = lilv_node_as_string(designationNode))

  1994.                     {

  1995.                         /**/ if (std::strcmp(designation, LV2_CORE__control) == 0)

  1996.                             rdfPort->Designation = LV2_PORT_DESIGNATION_CONTROL;

  1997.                         else if (std::strcmp(designation, LV2_CORE__enabled) == 0)

  1998.                             rdfPort->Designation = LV2_PORT_DESIGNATION_ENABLED;

  1999.                         else if (std::strcmp(designation, LV2_CORE__freeWheeling) == 0)

  2000.                             rdfPort->Designation = LV2_PORT_DESIGNATION_FREEWHEELING;

  2001.                         else if (std::strcmp(designation, LV2_CORE__latency) == 0)

  2002.                             rdfPort->Designation = LV2_PORT_DESIGNATION_LATENCY;

  2003.                         else if (std::strcmp(designation, LV2_PARAMETERS__sampleRate) == 0)

  2004.                             rdfPort->Designation = LV2_PORT_DESIGNATION_SAMPLE_RATE;

  2005.                         else if (std::strcmp(designation, LV2_TIME__bar) == 0)

  2006.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BAR;

  2007.                         else if (std::strcmp(designation, LV2_TIME__barBeat) == 0)

  2008.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BAR_BEAT;

  2009.                         else if (std::strcmp(designation, LV2_TIME__beat) == 0)

  2010.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEAT;

  2011.                         else if (std::strcmp(designation, LV2_TIME__beatUnit) == 0)

  2012.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEAT_UNIT;

  2013.                         else if (std::strcmp(designation, LV2_TIME__beatsPerBar) == 0)

  2014.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR;

  2015.                         else if (std::strcmp(designation, LV2_TIME__beatsPerMinute) == 0)

  2016.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE;

  2017.                         else if (std::strcmp(designation, LV2_TIME__frame) == 0)

  2018.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_FRAME;

  2019.                         else if (std::strcmp(designation, LV2_TIME__framesPerSecond) == 0)

  2020.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND;

  2021.                         else if (std::strcmp(designation, LV2_TIME__speed) == 0)

  2022.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_SPEED;

  2023.                         else if (std::strcmp(designation, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat) == 0)

  2024.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_TICKS_PER_BEAT;

  2025.                         else if (std::strncmp(designation, LV2_PARAMETERS_PREFIX, std::strlen(LV2_PARAMETERS_PREFIX)) == 0)

  2026.                             pass();

  2027.                         else if (std::strncmp(designation, LV2_PORT_GROUPS_PREFIX, std::strlen(LV2_PORT_GROUPS_PREFIX)) == 0)

  2028.                             pass();

  2029.                         else

  2030.                             carla_stderr("lv2_rdf_new(\"%s\") - got unknown port designation '%s'", uri, designation);

  2031.                     }

  2032.                     lilv_node_free(designationNode);

  2033.                 }

  2034.             }

  2035. 

  2036.             // --------------------------------------------------------------------------------------------------------

  2037.             // Set Port MIDI Map

  2038.             {

  2039.                 if (LilvNode* const midiMapNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.mm_defaultControl.me))

  2040.                 {

  2041.                     if (lilv_node_is_blank(midiMapNode))

  2042.                     {

  2043.                         Lilv::Nodes midiMapTypeNodes(lv2World.find_nodes(midiMapNode, lv2World.mm_controlType, nullptr));

  2044.                         Lilv::Nodes midiMapNumberNodes(lv2World.find_nodes(midiMapNode, lv2World.mm_controlNumber, nullptr));

  2045. 

  2046.                         if (midiMapTypeNodes.size() == 1 && midiMapNumberNodes.size() == 1)

  2047.                         {

  2048.                             if (const char* const midiMapType = midiMapTypeNodes.get_first().as_string())

  2049.                             {

  2050.                                 /**/ if (std::strcmp(midiMapType, LV2_MIDI_Map__CC) == 0)

  2051.                                     rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_CC;

  2052.                                 else if (std::strcmp(midiMapType, LV2_MIDI_Map__NRPN) == 0)

  2053.                                     rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_NRPN;

  2054.                                 else

  2055.                                     carla_stderr("lv2_rdf_new(\"%s\") - got unknown port Midi-Map type '%s'", uri, midiMapType);

  2056. 

  2057.                                 rdfPort->MidiMap.Number = static_cast<uint32_t>(midiMapNumberNodes.get_first().as_int());

  2058.                             }

  2059.                         }

  2060. 

  2061.                         lilv_nodes_free(const_cast<LilvNodes*>(midiMapTypeNodes.me));

  2062.                         lilv_nodes_free(const_cast<LilvNodes*>(midiMapNumberNodes.me));

  2063.                     }

  2064. 

  2065.                     lilv_node_free(midiMapNode);

  2066.                 }

  2067. 

  2068.                 // TODO - also check using new official MIDI API too

  2069.             }

  2070. 

  2071.             // --------------------------------------------------------------------------------------------------------

  2072.             // Set Port Points

  2073.             {

  2074.                 if (LilvNode* const defNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.value_default.me))

  2075.                 {

  2076.                     rdfPort->Points.Hints  |= LV2_PORT_POINT_DEFAULT;

  2077.                     rdfPort->Points.Default = lilv_node_as_float(defNode);

  2078.                     lilv_node_free(defNode);

  2079.                 }

  2080. 

  2081.                 if (LilvNode* const minNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.value_minimum.me))

  2082.                 {

  2083.                     rdfPort->Points.Hints  |= LV2_PORT_POINT_MINIMUM;

  2084.                     rdfPort->Points.Minimum = lilv_node_as_float(minNode);

  2085.                     lilv_node_free(minNode);

  2086.                 }

  2087. 

  2088.                 if (LilvNode* const maxNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.value_maximum.me))

  2089.                 {

  2090.                     rdfPort->Points.Hints  |= LV2_PORT_POINT_MAXIMUM;

  2091.                     rdfPort->Points.Maximum = lilv_node_as_float(maxNode);

  2092.                     lilv_node_free(maxNode);

  2093.                 }

  2094.             }

  2095. 

  2096.             // --------------------------------------------------------------------------------------------------------

  2097.             // Set Port Unit

  2098.             {

  2099.                 if (LilvNode* const unitUnitNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.unit_unit.me))

  2100.                 {

  2101.                     if (lilv_node_is_uri(unitUnitNode))

  2102.                     {

  2103.                         if (const char* const unitUnit = lilv_node_as_uri(unitUnitNode))

  2104.                         {

  2105.                             rdfPort->Unit.Hints |= LV2_PORT_UNIT_UNIT;

  2106. 

  2107.                             /**/ if (std::strcmp(unitUnit, LV2_UNITS__bar) == 0)

  2108.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_BAR;

  2109.                             else if (std::strcmp(unitUnit, LV2_UNITS__beat) == 0)

  2110.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_BEAT;

  2111.                             else if (std::strcmp(unitUnit, LV2_UNITS__bpm) == 0)

  2112.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_BPM;

  2113.                             else if (std::strcmp(unitUnit, LV2_UNITS__cent) == 0)

  2114.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_CENT;

  2115.                             else if (std::strcmp(unitUnit, LV2_UNITS__cm) == 0)

  2116.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_CM;

  2117.                             else if (std::strcmp(unitUnit, LV2_UNITS__coef) == 0)

  2118.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_COEF;

  2119.                             else if (std::strcmp(unitUnit, LV2_UNITS__db) == 0)

  2120.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_DB;

  2121.                             else if (std::strcmp(unitUnit, LV2_UNITS__degree) == 0)

  2122.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_DEGREE;

  2123.                             else if (std::strcmp(unitUnit, LV2_UNITS__frame) == 0)

  2124.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_FRAME;

  2125.                             else if (std::strcmp(unitUnit, LV2_UNITS__hz) == 0)

  2126.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_HZ;

  2127.                             else if (std::strcmp(unitUnit, LV2_UNITS__inch) == 0)

  2128.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_INCH;

  2129.                             else if (std::strcmp(unitUnit, LV2_UNITS__khz) == 0)

  2130.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_KHZ;

  2131.                             else if (std::strcmp(unitUnit, LV2_UNITS__km) == 0)

  2132.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_KM;

  2133.                             else if (std::strcmp(unitUnit, LV2_UNITS__m) == 0)

  2134.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_M;

  2135.                             else if (std::strcmp(unitUnit, LV2_UNITS__mhz) == 0)

  2136.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MHZ;

  2137.                             else if (std::strcmp(unitUnit, LV2_UNITS__midiNote) == 0)

  2138.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MIDINOTE;

  2139.                             else if (std::strcmp(unitUnit, LV2_UNITS__mile) == 0)

  2140.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MILE;

  2141.                             else if (std::strcmp(unitUnit, LV2_UNITS__min) == 0)

  2142.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MIN;

  2143.                             else if (std::strcmp(unitUnit, LV2_UNITS__mm) == 0)

  2144.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MM;

  2145.                             else if (std::strcmp(unitUnit, LV2_UNITS__ms) == 0)

  2146.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MS;

  2147.                             else if (std::strcmp(unitUnit, LV2_UNITS__oct) == 0)

  2148.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_OCT;

  2149.                             else if (std::strcmp(unitUnit, LV2_UNITS__pc) == 0)

  2150.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_PC;

  2151.                             else if (std::strcmp(unitUnit, LV2_UNITS__s) == 0)

  2152.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_S;

  2153.                             else if (std::strcmp(unitUnit, LV2_UNITS__semitone12TET) == 0)

  2154.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_SEMITONE;

  2155.                             else

  2156.                                 carla_stderr("lv2_rdf_new(\"%s\") - got unknown unit unit '%s'", uri, unitUnit);

  2157.                         }

  2158.                     }

  2159. 

  2160.                     if (LilvNode* const unitNameNode = lilv_world_get(lv2World.me, unitUnitNode, lv2World.unit_name.me, nullptr))

  2161.                     {

  2162.                         if (const char* const unitName = lilv_node_as_string(unitNameNode))

  2163.                         {

  2164.                             rdfPort->Unit.Hints |= LV2_PORT_UNIT_NAME;

  2165.                             rdfPort->Unit.Name   = carla_strdup(unitName);

  2166.                         }

  2167.                         lilv_node_free(unitNameNode);

  2168.                     }

  2169. 

  2170.                     if (LilvNode* const unitRenderNode = lilv_world_get(lv2World.me, unitUnitNode, lv2World.unit_render.me, nullptr))

  2171.                     {

  2172.                         if (const char* const unitRender = lilv_node_as_string(unitRenderNode))

  2173.                         {

  2174.                             rdfPort->Unit.Hints |= LV2_PORT_UNIT_RENDER;

  2175.                             rdfPort->Unit.Render = carla_strdup(unitRender);

  2176.                         }

  2177.                         lilv_node_free(unitRenderNode);

  2178.                     }

  2179. 

  2180.                     if (LilvNode* const unitSymbolNode = lilv_world_get(lv2World.me, unitUnitNode, lv2World.unit_symbol.me, nullptr))

  2181.                     {

  2182.                         if (const char* const unitSymbol = lilv_node_as_string(unitSymbolNode))

  2183.                         {

  2184.                             rdfPort->Unit.Hints |= LV2_PORT_UNIT_SYMBOL;

  2185.                             rdfPort->Unit.Symbol = carla_strdup(unitSymbol);

  2186.                         }

  2187.                         lilv_node_free(unitSymbolNode);

  2188.                     }

  2189. 

  2190.                     lilv_node_free(unitUnitNode);

  2191.                 }

  2192.             }

  2193. 

  2194.             // --------------------------------------------------------------------------------------------------------

  2195.             // Set Port Minimum Size

  2196.             {

  2197.                 if (LilvNode* const minimumSizeNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.rz_minSize.me))

  2198.                 {

  2199.                     const int minimumSize(lilv_node_as_int(minimumSizeNode));

  2200. 

  2201.                     if (minimumSize > 0)

  2202.                         rdfPort->MinimumSize = static_cast<uint32_t>(minimumSize);

  2203.                     else

  2204.                         carla_safe_assert_int("minimumSize > 0", __FILE__, __LINE__, minimumSize);

  2205. 

  2206.                     lilv_node_free(minimumSizeNode);

  2207.                 }

  2208.             }

  2209. 

  2210.             // --------------------------------------------------------------------------------------------------------

  2211.             // Set Port Scale Points

  2212.             {

  2213.                 Lilv::ScalePoints lilvScalePoints(lilvPort.get_scale_points());

  2214. 

  2215.                 if (const uint numScalePoints = lilvScalePoints.size())

  2216.                 {

  2217.                     rdfPort->ScalePointCount = numScalePoints;

  2218.                     rdfPort->ScalePoints = new LV2_RDF_PortScalePoint[numScalePoints];

  2219. 

  2220.                     // get all scalepoints and sort them by value

  2221.                     LilvScalePointMap sortedpoints;

  2222. 

  2223.                     LILV_FOREACH(scale_points, it, lilvScalePoints)

  2224.                     {

  2225.                         Lilv::ScalePoint lilvScalePoint(lilvScalePoints.get(it));

  2226. 

  2227.                         CARLA_SAFE_ASSERT_CONTINUE(lilvScalePoint.get_label() != nullptr);

  2228. 

  2229.                         if (const LilvNode* const valuenode = lilvScalePoint.get_value())

  2230.                         {

  2231.                             const double valueid = lilv_node_as_float(valuenode);

  2232.                             sortedpoints[valueid] = lilvScalePoint.me;

  2233.                         }

  2234.                     }

  2235. 

  2236.                     // now safe to store, sorted by using std::map

  2237.                     uint h = 0;

  2238.                     for (LilvScalePointMap::iterator it=sortedpoints.begin(), end=sortedpoints.end(); it != end; ++it)

  2239.                     {

  2240.                         CARLA_SAFE_ASSERT_BREAK(h < numScalePoints);

  2241.                         LV2_RDF_PortScalePoint* const rdfScalePoint(&rdfPort->ScalePoints[h++]);

  2242. 

  2243.                         const LilvScalePoint* const scalepoint = it->second;

  2244. 

  2245.                         const LilvNode* const xlabel = lilv_scale_point_get_label(scalepoint);

  2246.                         const LilvNode* const xvalue = lilv_scale_point_get_value(scalepoint);

  2247. 

  2248.                         rdfScalePoint->Label = carla_strdup(lilv_node_as_string(xlabel));

  2249.                         rdfScalePoint->Value = lilv_node_as_float(xvalue);

  2250.                     }

  2251.                 }

  2252. 

  2253.                 lilv_nodes_free(const_cast<LilvNodes*>(lilvScalePoints.me));

  2254.             }

  2255.         }

  2256.     }

  2257. 

  2258.     // ----------------------------------------------------------------------------------------------------------------

  2259.     // Set Plugin Parameters

  2260.     {

  2261.         Lilv::Nodes patchWritableNodes(lilvPlugin.get_value(lv2World.patch_writable));

  2262. 

  2263.         if (const uint numParameters = patchWritableNodes.size())

  2264.         {

  2265.             rdfDescriptor->ParameterCount = numParameters;

  2266.             rdfDescriptor->Parameters = new LV2_RDF_Parameter[numParameters];

  2267. 

  2268.             uint h = 0;

  2269.             LILV_FOREACH(nodes, it, patchWritableNodes)

  2270.             {

  2271.                 CARLA_SAFE_ASSERT_BREAK(h < numParameters);

  2272. 

  2273.                 Lilv::Node patchWritableNode(patchWritableNodes.get(it));

  2274.                 LV2_RDF_Parameter* const rdfParam(&rdfDescriptor->Parameters[h++]);

  2275. 

  2276.                 CARLA_SAFE_ASSERT_CONTINUE(patchWritableNode.is_uri());

  2277. 

  2278.                 rdfParam->URI = carla_strdup(patchWritableNode.as_uri());

  2279. 

  2280.                 if (LilvNode* const label = lilv_world_get(lv2World.me, patchWritableNode,

  2281.                                                            lv2World.rdfs_range.me, nullptr))

  2282.                 {

  2283.                     rdfParam->Range = carla_strdup(lilv_node_as_string(label));

  2284.                 }

  2285.                 if (LilvNode* const label = lilv_world_get(lv2World.me, patchWritableNode,

  2286.                                                            lv2World.rdfs_label.me, nullptr))

  2287.                 {

  2288.                     rdfParam->Label = carla_strdup(lilv_node_as_string(label));

  2289.                 }

  2290.                 if (LilvNode* const comment = lilv_world_get(lv2World.me, patchWritableNode,

  2291.                                                              lv2World.rdfs_comment.me, nullptr))

  2292.                 {

  2293.                     rdfParam->Comment = carla_strdup(lilv_node_as_string(comment));

  2294.                 }

  2295. 

  2296.                 // TODO: MidiMap, Points, Unit;

  2297.             }

  2298.         }

  2299. 

  2300.         lilv_nodes_free(const_cast<LilvNodes*>(patchWritableNodes.me));

  2301.     }

  2302. 

  2303.     // ----------------------------------------------------------------------------------------------------------------

  2304.     // Set Plugin Presets

  2305. 

  2306.     if (loadPresets)

  2307.     {

  2308.         Lilv::Nodes presetNodes(lilvPlugin.get_related(lv2World.preset_preset));

  2309. 

  2310.         if (presetNodes.size() > 0)

  2311.         {

  2312.             // create a list of preset URIs (for sorting and unique-ness)

  2313. #ifdef USE_QT

  2314.             QStringList presetListURIs;

  2315. 

  2316.             LILV_FOREACH(nodes, it, presetNodes)

  2317.             {

  2318.                 Lilv::Node presetNode(presetNodes.get(it));

  2319. 

  2320.                 QString presetURI(presetNode.as_uri());

  2321. 

  2322.                 if (! (presetURI.trimmed().isEmpty() || presetListURIs.contains(presetURI)))

  2323.                     presetListURIs.append(presetURI);

  2324.             }

  2325. 

  2326.             presetListURIs.sort();

  2327. 

  2328.             rdfDescriptor->PresetCount = static_cast<uint32_t>(presetListURIs.count());

  2329. #else

  2330.             water::StringArray presetListURIs;

  2331. 

  2332.             LILV_FOREACH(nodes, it, presetNodes)

  2333.             {

  2334.                 Lilv::Node presetNode(presetNodes.get(it));

  2335. 

  2336.                 water::String presetURI(presetNode.as_uri());

  2337. 

  2338.                 if (presetURI.trim().isNotEmpty())

  2339.                     presetListURIs.addIfNotAlreadyThere(presetURI);

  2340.             }

  2341. 

  2342.             presetListURIs.sortNatural();

  2343. 

  2344.             rdfDescriptor->PresetCount = static_cast<uint32_t>(presetListURIs.size());

  2345. #endif

  2346. 

  2347.             // create presets with unique URIs

  2348.             rdfDescriptor->Presets = new LV2_RDF_Preset[rdfDescriptor->PresetCount];

  2349. 

  2350.             // set preset data

  2351.             LILV_FOREACH(nodes, it, presetNodes)

  2352.             {

  2353.                 Lilv::Node presetNode(presetNodes.get(it));

  2354. 

  2355.                 const char* const presetURI(presetNode.as_uri());

  2356.                 CARLA_SAFE_ASSERT_CONTINUE(presetURI != nullptr && presetURI[0] != '\0');

  2357. 

  2358.                 // try to find label without loading the preset resource first

  2359.                 Lilv::Nodes presetLabelNodes(lv2World.find_nodes(presetNode, lv2World.rdfs_label, nullptr));

  2360. 

  2361.                 // failed, try loading resource

  2362.                 if (presetLabelNodes.size() == 0)

  2363.                 {

  2364.                     // if loading resource fails, skip this preset

  2365.                     if (lv2World.load_resource(presetNode) == -1)

  2366.                         continue;

  2367. 

  2368.                     // ok, let's try again

  2369.                     presetLabelNodes = lv2World.find_nodes(presetNode, lv2World.rdfs_label, nullptr);

  2370.                 }

  2371. 

  2372.                 if (presetLabelNodes.size() > 0)

  2373.                 {

  2374. #ifdef USE_QT

  2375.                     const int index(presetListURIs.indexOf(QString(presetURI)));

  2376. #else

  2377.                     const int index(presetListURIs.indexOf(water::String(presetURI)));

  2378. #endif

  2379.                     CARLA_SAFE_ASSERT_CONTINUE(index >= 0 && index < static_cast<int>(rdfDescriptor->PresetCount));

  2380. 

  2381.                     LV2_RDF_Preset* const rdfPreset(&rdfDescriptor->Presets[index]);

  2382. 

  2383.                     // ---------------------------------------------------

  2384.                     // Set Preset Information

  2385. 

  2386.                     rdfPreset->URI = carla_strdup(presetURI);

  2387. 

  2388.                     if (const char* const label = presetLabelNodes.get_first().as_string())

  2389.                         rdfPreset->Label = carla_strdup(label);

  2390. 

  2391.                     lilv_nodes_free(const_cast<LilvNodes*>(presetLabelNodes.me));

  2392.                 }

  2393.             }

  2394.         }

  2395. 

  2396.         lilv_nodes_free(const_cast<LilvNodes*>(presetNodes.me));

  2397.     }

  2398. 

  2399.     // ----------------------------------------------------------------------------------------------------------------

  2400.     // Set Plugin Features

  2401.     {

  2402.         Lilv::Nodes lilvFeatureNodes(lilvPlugin.get_supported_features());

  2403. 

  2404.         if (const uint numFeatures = lilvFeatureNodes.size())

  2405.         {

  2406.             Lilv::Nodes lilvFeatureNodesR(lilvPlugin.get_required_features());

  2407. 

  2408.             rdfDescriptor->FeatureCount = numFeatures;

  2409.             rdfDescriptor->Features = new LV2_RDF_Feature[numFeatures];

  2410. 

  2411.             uint h = 0;

  2412.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  2413.             {

  2414.                 CARLA_SAFE_ASSERT_BREAK(h < numFeatures);

  2415. 

  2416.                 Lilv::Node lilvFeatureNode(lilvFeatureNodes.get(it));

  2417.                 LV2_RDF_Feature* const rdfFeature(&rdfDescriptor->Features[h++]);

  2418. 

  2419.                 rdfFeature->Required = lilvFeatureNodesR.contains(lilvFeatureNode);

  2420. 

  2421.                 if (const char* const featureURI = lilvFeatureNode.as_uri())

  2422.                     rdfFeature->URI = carla_strdup(featureURI);

  2423.                 else

  2424.                     rdfFeature->URI = nullptr;

  2425.             }

  2426. 

  2427.             lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodesR.me));

  2428.         }

  2429. 

  2430.         lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodes.me));

  2431.     }

  2432. 

  2433.     // ----------------------------------------------------------------------------------------------------------------

  2434.     // Set Plugin Extensions

  2435.     {

  2436.         Lilv::Nodes lilvExtensionDataNodes(lilvPlugin.get_extension_data());

  2437. 

  2438.         if (const uint numExtensions = lilvExtensionDataNodes.size())

  2439.         {

  2440.             rdfDescriptor->ExtensionCount = numExtensions;

  2441.             rdfDescriptor->Extensions = new LV2_URI[numExtensions];

  2442. 

  2443.             uint h = 0;

  2444.             LILV_FOREACH(nodes, it, lilvExtensionDataNodes)

  2445.             {

  2446.                 CARLA_SAFE_ASSERT_BREAK(h < numExtensions);

  2447. 

  2448.                 Lilv::Node lilvExtensionDataNode(lilvExtensionDataNodes.get(it));

  2449.                 LV2_URI* const rdfExtension(&rdfDescriptor->Extensions[h++]);

  2450. 

  2451.                 if (lilvExtensionDataNode.is_uri())

  2452.                 {

  2453.                     if (const char* const extURI = lilvExtensionDataNode.as_uri())

  2454.                     {

  2455.                         *rdfExtension = carla_strdup(extURI);

  2456.                         continue;

  2457.                     }

  2458.                 }

  2459.                 *rdfExtension = nullptr;

  2460.             }

  2461. 

  2462.             for (uint32_t x=h; x < rdfDescriptor->ExtensionCount; ++x)

  2463.                 rdfDescriptor->Extensions[x] = nullptr;

  2464.         }

  2465. 

  2466.         lilv_nodes_free(const_cast<LilvNodes*>(lilvExtensionDataNodes.me));

  2467.     }

  2468. 

  2469.     // ----------------------------------------------------------------------------------------------------------------

  2470.     // Set Plugin UIs

  2471.     {

  2472.         Lilv::UIs lilvUIs(lilvPlugin.get_uis());

  2473. 

  2474.         if (const uint numUIs = lilvUIs.size())

  2475.         {

  2476.             rdfDescriptor->UICount = numUIs;

  2477.             rdfDescriptor->UIs = new LV2_RDF_UI[numUIs];

  2478. 

  2479.             uint h = 0;

  2480.             LILV_FOREACH(uis, it, lilvUIs)

  2481.             {

  2482.                 CARLA_SAFE_ASSERT_BREAK(h < numUIs);

  2483. 

  2484.                 Lilv::UI lilvUI(lilvUIs.get(it));

  2485.                 LV2_RDF_UI* const rdfUI(&rdfDescriptor->UIs[h++]);

  2486. 

  2487.                 lv2World.load_resource(lilvUI.get_uri());

  2488. 

  2489.                 // ----------------------------------------------------------------------------------------------------

  2490.                 // Set UI Type

  2491. 

  2492.                 /**/ if (lilvUI.is_a(lv2World.ui_gtk2))

  2493.                     rdfUI->Type = LV2_UI_GTK2;

  2494.                 else if (lilvUI.is_a(lv2World.ui_gtk3))

  2495.                     rdfUI->Type = LV2_UI_GTK3;

  2496.                 else if (lilvUI.is_a(lv2World.ui_qt4))

  2497.                     rdfUI->Type = LV2_UI_QT4;

  2498.                 else if (lilvUI.is_a(lv2World.ui_qt5))

  2499.                     rdfUI->Type = LV2_UI_QT5;

  2500.                 else if (lilvUI.is_a(lv2World.ui_cocoa))

  2501.                     rdfUI->Type = LV2_UI_COCOA;

  2502.                 else if (lilvUI.is_a(lv2World.ui_windows))

  2503.                     rdfUI->Type = LV2_UI_WINDOWS;

  2504.                 else if (lilvUI.is_a(lv2World.ui_x11))

  2505.                     rdfUI->Type = LV2_UI_X11;

  2506.                 else if (lilvUI.is_a(lv2World.ui_external))

  2507.                     rdfUI->Type = LV2_UI_EXTERNAL;

  2508.                 else if (lilvUI.is_a(lv2World.ui_externalOld))

  2509.                     rdfUI->Type = LV2_UI_OLD_EXTERNAL;

  2510.                 else if (lilvUI.is_a(lv2World.ui_externalOld2))

  2511.                     pass();

  2512.                 else

  2513.                     carla_stderr("lv2_rdf_new(\"%s\") - UI '%s' is of unknown type", uri, lilvUI.get_uri().as_uri());

  2514. 

  2515.                 // ----------------------------------------------------------------------------------------------------

  2516.                 // Set UI Information

  2517.                 {

  2518.                     if (const char* const uiURI = lilvUI.get_uri().as_uri())

  2519.                         rdfUI->URI = carla_strdup(uiURI);

  2520. 

  2521.                     if (const char* const uiBinary = lilvUI.get_binary_uri().as_string())

  2522.                         rdfUI->Binary = carla_strdup_free(lilv_file_uri_parse(uiBinary, nullptr));

  2523. 

  2524.                     if (const char* const uiBundle = lilvUI.get_bundle_uri().as_string())

  2525.                         rdfUI->Bundle = carla_strdup_free(lilv_file_uri_parse(uiBundle, nullptr));

  2526.                 }

  2527. 

  2528.                 // ----------------------------------------------------------------------------------------------------

  2529.                 // Set UI Features

  2530.                 {

  2531.                     Lilv::Nodes lilvFeatureNodes(lilvUI.get_supported_features());

  2532. 

  2533.                     if (const uint numFeatures = lilvFeatureNodes.size())

  2534.                     {

  2535.                         Lilv::Nodes lilvFeatureNodesR(lilvUI.get_required_features());

  2536. 

  2537.                         rdfUI->FeatureCount = numFeatures;

  2538.                         rdfUI->Features = new LV2_RDF_Feature[numFeatures];

  2539. 

  2540.                         uint h2 = 0;

  2541.                         LILV_FOREACH(nodes, it2, lilvFeatureNodes)

  2542.                         {

  2543.                             CARLA_SAFE_ASSERT_BREAK(h2 < numFeatures);

  2544. 

  2545.                             Lilv::Node lilvFeatureNode(lilvFeatureNodes.get(it2));

  2546.                             LV2_RDF_Feature* const rdfFeature(&rdfUI->Features[h2++]);

  2547. 

  2548.                             rdfFeature->Required = lilvFeatureNodesR.contains(lilvFeatureNode);

  2549. 

  2550.                             if (const char* const featureURI = lilvFeatureNode.as_uri())

  2551.                                 rdfFeature->URI = carla_strdup(featureURI);

  2552.                             else

  2553.                                 rdfFeature->URI = nullptr;

  2554.                         }

  2555. 

  2556.                         lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodesR.me));

  2557.                     }

  2558. 

  2559.                     lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodes.me));

  2560.                 }

  2561. 

  2562.                 // ----------------------------------------------------------------------------------------------------

  2563.                 // Set UI Extensions

  2564.                 {

  2565.                     Lilv::Nodes lilvExtensionDataNodes(lilvUI.get_extension_data());

  2566. 

  2567.                     if (const uint numExtensions = lilvExtensionDataNodes.size() > 0)

  2568.                     {

  2569.                         rdfUI->ExtensionCount = numExtensions;

  2570.                         rdfUI->Extensions = new LV2_URI[numExtensions];

  2571. 

  2572.                         uint h2 = 0;

  2573.                         LILV_FOREACH(nodes, it2, lilvExtensionDataNodes)

  2574.                         {

  2575.                             CARLA_SAFE_ASSERT_BREAK(h2 < numExtensions);

  2576. 

  2577.                             Lilv::Node lilvExtensionDataNode(lilvExtensionDataNodes.get(it2));

  2578.                             LV2_URI* const rdfExtension(&rdfUI->Extensions[h2++]);

  2579. 

  2580.                             if (lilvExtensionDataNode.is_uri())

  2581.                             {

  2582.                                 if (const char* const extURI = lilvExtensionDataNode.as_uri())

  2583.                                 {

  2584.                                     *rdfExtension = carla_strdup(extURI);

  2585.                                     continue;

  2586.                                 }

  2587.                             }

  2588.                             *rdfExtension = nullptr;

  2589.                         }

  2590. 

  2591.                         for (uint x2=h2; x2 < rdfUI->ExtensionCount; ++x2)

  2592.                             rdfUI->Extensions[x2] = nullptr;

  2593.                     }

  2594. 

  2595.                     lilv_nodes_free(const_cast<LilvNodes*>(lilvExtensionDataNodes.me));

  2596.                 }

  2597. 

  2598.                 // ----------------------------------------------------------------------------------------------------

  2599.                 // Set UI Port Notifications

  2600.                 {

  2601.                     Lilv::Nodes portNotifNodes(lv2World.find_nodes(lilvUI.get_uri(), lv2World.ui_portNotif.me, nullptr));

  2602. 

  2603.                     if (const uint portNotifCount = portNotifNodes.size())

  2604.                     {

  2605.                         rdfUI->PortNotificationCount = portNotifCount;

  2606.                         rdfUI->PortNotifications = new LV2_RDF_UI_PortNotification[portNotifCount];

  2607. 

  2608.                         uint h2 = 0;

  2609.                         LILV_FOREACH(nodes, it2, portNotifNodes)

  2610.                         {

  2611.                             CARLA_SAFE_ASSERT_BREAK(h2 < portNotifCount);

  2612. 

  2613.                             Lilv::Node portNotifNode(portNotifNodes.get(it2));

  2614.                             LV2_RDF_UI_PortNotification* const rdfPortNotif(&rdfUI->PortNotifications[h2++]);

  2615. 

  2616.                             LilvNode* const protocolNode = lilv_world_get(lv2World.me, portNotifNode,

  2617.                                                                           lv2World.ui_protocol.me, nullptr);

  2618. 

  2619.                             if (protocolNode != nullptr)

  2620.                             {

  2621.                                 CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_uri(protocolNode));

  2622. 

  2623.                                 const char* const protocol = lilv_node_as_uri(protocolNode);

  2624.                                 CARLA_SAFE_ASSERT_CONTINUE(protocol != nullptr && protocol[0] != '\0');

  2625. 

  2626.                                 /**/ if (std::strcmp(protocol, LV2_UI__floatProtocol) == 0)

  2627.                                     rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_FLOAT;

  2628.                                 else if (std::strcmp(protocol, LV2_UI__peakProtocol) == 0)

  2629.                                     rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_PEAK;

  2630.                             }

  2631.                             else

  2632.                             {

  2633.                                 rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_FLOAT;

  2634.                             }

  2635. 

  2636.                             /**/ if (LilvNode* const symbolNode = lilv_world_get(lv2World.me, portNotifNode,

  2637.                                                                                  lv2World.symbol.me, nullptr))

  2638.                             {

  2639.                                 CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_string(symbolNode));

  2640. 

  2641.                                 const char* const symbol = lilv_node_as_string(symbolNode);

  2642.                                 CARLA_SAFE_ASSERT_CONTINUE(symbol != nullptr && symbol[0] != '\0');

  2643. 

  2644.                                 rdfPortNotif->Symbol = carla_strdup(symbol);

  2645. 

  2646.                                 lilv_node_free(symbolNode);

  2647.                             }

  2648.                             else if (LilvNode* const indexNode = lilv_world_get(lv2World.me, portNotifNode,

  2649.                                                                                 lv2World.ui_portIndex.me, nullptr))

  2650.                             {

  2651.                                 CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_int(indexNode));

  2652. 

  2653.                                 const int index = lilv_node_as_int(indexNode);

  2654.                                 CARLA_SAFE_ASSERT_CONTINUE(index >= 0);

  2655. 

  2656.                                 rdfPortNotif->Index = static_cast<uint32_t>(index);

  2657. 

  2658.                                 lilv_node_free(indexNode);

  2659.                             }

  2660. 

  2661.                             lilv_node_free(protocolNode);

  2662.                         }

  2663.                     }

  2664. 

  2665.                     lilv_nodes_free(const_cast<LilvNodes*>(portNotifNodes.me));

  2666.                 }

  2667.             }

  2668.         }

  2669. 

  2670.         lilv_nodes_free(const_cast<LilvNodes*>(lilvUIs.me));

  2671.     }

  2672. 

  2673.     return rdfDescriptor;

  2674. }

  2675. 

  2676. // --------------------------------------------------------------------------------------------------------------------

  2677. // Check if we support a plugin port

  2678. 

  2679. static inline

  2680. bool is_lv2_port_supported(const LV2_Property types) noexcept

  2681. {

  2682.     if (LV2_IS_PORT_CONTROL(types))

  2683.         return true;

  2684.     if (LV2_IS_PORT_AUDIO(types))

  2685.         return true;

  2686.     if (LV2_IS_PORT_CV(types))

  2687.         return true;

  2688.     if (LV2_IS_PORT_ATOM_SEQUENCE(types))

  2689.         return true;

  2690.     if (LV2_IS_PORT_EVENT(types))

  2691.         return true;

  2692.     if (LV2_IS_PORT_MIDI_LL(types))

  2693.         return true;

  2694.     return false;

  2695. }

  2696. 

  2697. // --------------------------------------------------------------------------------------------------------------------

  2698. // Check if we support a plugin feature

  2699. 

  2700. static inline

  2701. bool is_lv2_feature_supported(const LV2_URI uri) noexcept

  2702. {

  2703.     CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', false);

  2704. 

  2705.     if (std::strcmp(uri, LV2_BUF_SIZE__boundedBlockLength) == 0)

  2706.         return true;

  2707.     if (std::strcmp(uri, LV2_BUF_SIZE__fixedBlockLength) == 0)

  2708.         return true;

  2709.     if (std::strcmp(uri, LV2_BUF_SIZE__powerOf2BlockLength) == 0)

  2710.         return true;

  2711.     if (std::strcmp(uri, LV2_CORE__hardRTCapable) == 0)

  2712.         return true;

  2713.     if (std::strcmp(uri, LV2_CORE__inPlaceBroken) == 0)

  2714.         return true;

  2715.     if (std::strcmp(uri, LV2_CORE__isLive) == 0)

  2716.         return true;

  2717.     if (std::strcmp(uri, LV2_EVENT_URI) == 0)

  2718.         return true;

  2719.     if (std::strcmp(uri, LV2_LOG__log) == 0)

  2720.         return true;

  2721.     if (std::strcmp(uri, LV2_OPTIONS__options) == 0)

  2722.         return true;

  2723.     if (std::strcmp(uri, LV2_PROGRAMS__Host) == 0)

  2724.         return true;

  2725.     if (std::strcmp(uri, LV2_RESIZE_PORT__resize) == 0)

  2726.         return true;

  2727.     if (std::strcmp(uri, LV2_RTSAFE_MEMORY_POOL__Pool) == 0)

  2728.         return true;

  2729.     if (std::strcmp(uri, LV2_RTSAFE_MEMORY_POOL_DEPRECATED_URI) == 0)

  2730.         return true;

  2731.     if (std::strcmp(uri, LV2_STATE__loadDefaultState) == 0)

  2732.         return true;

  2733.     if (std::strcmp(uri, LV2_STATE__makePath) == 0)

  2734.         return true;

  2735.     if (std::strcmp(uri, LV2_STATE__mapPath) == 0)

  2736.         return true;

  2737.     if (std::strcmp(uri, LV2_PORT_PROPS__supportsStrictBounds) == 0)

  2738.         return true;

  2739.     if (std::strcmp(uri, LV2_URI_MAP_URI) == 0)

  2740.         return true;

  2741.     if (std::strcmp(uri, LV2_URID__map) == 0)

  2742.         return true;

  2743.     if (std::strcmp(uri, LV2_URID__unmap) == 0)

  2744.         return true;

  2745.     if (std::strcmp(uri, LV2_WORKER__schedule) == 0)

  2746.         return true;

  2747.     return false;

  2748. }

  2749. 

  2750. // --------------------------------------------------------------------------------------------------------------------

  2751. // Check if we support a plugin or UI feature

  2752. 

  2753. static inline

  2754. bool is_lv2_ui_feature_supported(const LV2_URI uri) noexcept

  2755. {

  2756.     CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', false);

  2757. 

  2758.     if (is_lv2_feature_supported(uri))

  2759.         return true;

  2760. #ifndef BUILD_BRIDGE_UI

  2761.     if (std::strcmp(uri, LV2_DATA_ACCESS_URI) == 0)

  2762.         return true;

  2763.     if (std::strcmp(uri, LV2_INSTANCE_ACCESS_URI) == 0)

  2764.         return true;

  2765. #endif

  2766.     if (std::strcmp(uri, LV2_UI__fixedSize) == 0)

  2767.         return true;

  2768.     if (std::strcmp(uri, LV2_UI__idleInterface) == 0)

  2769.         return true;

  2770.     if (std::strcmp(uri, LV2_UI__makeResident) == 0)

  2771.         return true;

  2772.     if (std::strcmp(uri, LV2_UI__makeSONameResident) == 0)

  2773.         return true;

  2774.     if (std::strcmp(uri, LV2_UI__noUserResize) == 0)

  2775.         return true;

  2776.     if (std::strcmp(uri, LV2_UI__parent) == 0)

  2777.         return true;

  2778.     if (std::strcmp(uri, LV2_UI__portMap) == 0)

  2779.         return true;

  2780.     if (std::strcmp(uri, LV2_UI__portSubscribe) == 0)

  2781.         return true;

  2782.     if (std::strcmp(uri, LV2_UI__resize) == 0)

  2783.         return true;

  2784.     if (std::strcmp(uri, LV2_UI__touch) == 0)

  2785.         return true;

  2786.     if (std::strcmp(uri, LV2_EXTERNAL_UI__Widget) == 0)

  2787.         return true;

  2788.     if (std::strcmp(uri, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)

  2789.         return true;

  2790.     return false;

  2791. }

  2792. 

  2793. // --------------------------------------------------------------------------------------------------------------------

  2794. 

  2795. #endif // CARLA_LV2_UTILS_HPP_INCLUDED