falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
4092 Commits
17 Branches
95MB
Tree: cc3268a8be
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cc3268a8be'
${ noResults }
Carla/source/utils/CarlaLv2Utils.hpp

2665 lines
107KB
Raw Blame History 

  1. /*

  2.  * Carla LV2 utils

  3.  * Copyright (C) 2011-2017 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. 

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

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

  104. 

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

  106. 

  107. #define LV2_UI__makeResident       LV2_UI_PREFIX "makeResident"

  108. #define LV2_UI__makeSONameResident LV2_UI_PREFIX "makeSONameResident"

  109. 

  110. // TODO: update LV2 headers once again

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

  112. 

  113. // --------------------------------------------------------------------------------------------------------------------

  114. // Custom Atom types

  115. 

  116. struct LV2_Atom_MidiEvent {

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

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

  119. };

  120. 

  121. static inline

  122. uint32_t lv2_atom_total_size(const LV2_Atom_MidiEvent& midiEv)

  123. {

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

  125. }

  126. 

  127. // ---------------------------------------------------------------------------------------------------------------------

  128. // -Weffc++ compat ext widget

  129. 

  130. extern "C" {

  131. 

  132. typedef struct _LV2_External_UI_Widget_Compat {

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

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

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

  136. 

  137.   _LV2_External_UI_Widget_Compat() noexcept

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

  139. 

  140. } LV2_External_UI_Widget_Compat;

  141. 

  142. }

  143. 

  144. // --------------------------------------------------------------------------------------------------------------------

  145. // Our LV2 World class

  146. 

  147. class Lv2WorldClass : public Lilv::World

  148. {

  149. public:

  150.     // Base Types

  151.     Lilv::Node port;

  152.     Lilv::Node symbol;

  153.     Lilv::Node designation;

  154.     Lilv::Node freeWheeling;

  155.     Lilv::Node reportsLatency;

  156. 

  157.     // Plugin Types

  158.     Lilv::Node class_allpass;

  159.     Lilv::Node class_amplifier;

  160.     Lilv::Node class_analyzer;

  161.     Lilv::Node class_bandpass;

  162.     Lilv::Node class_chorus;

  163.     Lilv::Node class_comb;

  164.     Lilv::Node class_compressor;

  165.     Lilv::Node class_constant;

  166.     Lilv::Node class_converter;

  167.     Lilv::Node class_delay;

  168.     Lilv::Node class_distortion;

  169.     Lilv::Node class_dynamics;

  170.     Lilv::Node class_eq;

  171.     Lilv::Node class_envelope;

  172.     Lilv::Node class_expander;

  173.     Lilv::Node class_filter;

  174.     Lilv::Node class_flanger;

  175.     Lilv::Node class_function;

  176.     Lilv::Node class_gate;

  177.     Lilv::Node class_generator;

  178.     Lilv::Node class_highpass;

  179.     Lilv::Node class_instrument;

  180.     Lilv::Node class_limiter;

  181.     Lilv::Node class_lowpass;

  182.     Lilv::Node class_mixer;

  183.     Lilv::Node class_modulator;

  184.     Lilv::Node class_multiEQ;

  185.     Lilv::Node class_oscillator;

  186.     Lilv::Node class_paraEQ;

  187.     Lilv::Node class_phaser;

  188.     Lilv::Node class_pitch;

  189.     Lilv::Node class_reverb;

  190.     Lilv::Node class_simulator;

  191.     Lilv::Node class_spatial;

  192.     Lilv::Node class_spectral;

  193.     Lilv::Node class_utility;

  194.     Lilv::Node class_waveshaper;

  195. 

  196.     // Port Types

  197.     Lilv::Node port_input;

  198.     Lilv::Node port_output;

  199.     Lilv::Node port_control;

  200.     Lilv::Node port_audio;

  201.     Lilv::Node port_cv;

  202.     Lilv::Node port_atom;

  203.     Lilv::Node port_event;

  204.     Lilv::Node port_midi;

  205. 

  206.     // Port Properties

  207.     Lilv::Node pprop_optional;

  208.     Lilv::Node pprop_enumeration;

  209.     Lilv::Node pprop_integer;

  210.     Lilv::Node pprop_sampleRate;

  211.     Lilv::Node pprop_toggled;

  212.     Lilv::Node pprop_artifacts;

  213.     Lilv::Node pprop_continuousCV;

  214.     Lilv::Node pprop_discreteCV;

  215.     Lilv::Node pprop_expensive;

  216.     Lilv::Node pprop_strictBounds;

  217.     Lilv::Node pprop_logarithmic;

  218.     Lilv::Node pprop_notAutomatic;

  219.     Lilv::Node pprop_notOnGUI;

  220.     Lilv::Node pprop_trigger;

  221.     Lilv::Node pprop_nonAutomable;

  222. 

  223.     // Unit Hints

  224.     Lilv::Node unit_name;

  225.     Lilv::Node unit_render;

  226.     Lilv::Node unit_symbol;

  227.     Lilv::Node unit_unit;

  228. 

  229.     // UI Types

  230.     Lilv::Node ui_gtk2;

  231.     Lilv::Node ui_gtk3;

  232.     Lilv::Node ui_qt4;

  233.     Lilv::Node ui_qt5;

  234.     Lilv::Node ui_cocoa;

  235.     Lilv::Node ui_windows;

  236.     Lilv::Node ui_x11;

  237.     Lilv::Node ui_external;

  238.     Lilv::Node ui_externalOld;

  239.     Lilv::Node ui_externalOld2;

  240. 

  241.     // Misc

  242.     Lilv::Node atom_bufferType;

  243.     Lilv::Node atom_sequence;

  244.     Lilv::Node atom_supports;

  245. 

  246.     Lilv::Node preset_preset;

  247. 

  248.     Lilv::Node state_state;

  249. 

  250.     Lilv::Node ui_portNotif;

  251.     Lilv::Node ui_protocol;

  252. 

  253.     Lilv::Node value_default;

  254.     Lilv::Node value_minimum;

  255.     Lilv::Node value_maximum;

  256. 

  257.     Lilv::Node rz_asLargeAs;

  258.     Lilv::Node rz_minSize;

  259. 

  260.     // Port Data Types

  261.     Lilv::Node midi_event;

  262.     Lilv::Node patch_message;

  263.     Lilv::Node time_position;

  264. 

  265.     // MIDI CC

  266.     Lilv::Node mm_defaultControl;

  267.     Lilv::Node mm_controlType;

  268.     Lilv::Node mm_controlNumber;

  269. 

  270.     // Other

  271.     Lilv::Node dct_replaces;

  272.     Lilv::Node doap_license;

  273.     Lilv::Node rdf_type;

  274.     Lilv::Node rdfs_label;

  275. 

  276.     bool needsInit;

  277. 

  278.     const LilvPlugins* allPlugins;

  279.     const LilvPlugin** cachedPlugins;

  280.     uint pluginCount;

  281. 

  282.     // ----------------------------------------------------------------------------------------------------------------

  283. 

  284.     Lv2WorldClass()

  285.         : Lilv::World(),

  286.           port               (new_uri(LV2_CORE__port)),

  287.           symbol             (new_uri(LV2_CORE__symbol)),

  288.           designation        (new_uri(LV2_CORE__designation)),

  289.           freeWheeling       (new_uri(LV2_CORE__freeWheeling)),

  290.           reportsLatency     (new_uri(LV2_CORE__reportsLatency)),

  291. 

  292.           class_allpass      (new_uri(LV2_CORE__AllpassPlugin)),

  293.           class_amplifier    (new_uri(LV2_CORE__AmplifierPlugin)),

  294.           class_analyzer     (new_uri(LV2_CORE__AnalyserPlugin)),

  295.           class_bandpass     (new_uri(LV2_CORE__BandpassPlugin)),

  296.           class_chorus       (new_uri(LV2_CORE__ChorusPlugin)),

  297.           class_comb         (new_uri(LV2_CORE__CombPlugin)),

  298.           class_compressor   (new_uri(LV2_CORE__CompressorPlugin)),

  299.           class_constant     (new_uri(LV2_CORE__ConstantPlugin)),

  300.           class_converter    (new_uri(LV2_CORE__ConverterPlugin)),

  301.           class_delay        (new_uri(LV2_CORE__DelayPlugin)),

  302.           class_distortion   (new_uri(LV2_CORE__DistortionPlugin)),

  303.           class_dynamics     (new_uri(LV2_CORE__DynamicsPlugin)),

  304.           class_eq           (new_uri(LV2_CORE__EQPlugin)),

  305.           class_envelope     (new_uri(LV2_CORE__EnvelopePlugin)),

  306.           class_expander     (new_uri(LV2_CORE__ExpanderPlugin)),

  307.           class_filter       (new_uri(LV2_CORE__FilterPlugin)),

  308.           class_flanger      (new_uri(LV2_CORE__FlangerPlugin)),

  309.           class_function     (new_uri(LV2_CORE__FunctionPlugin)),

  310.           class_gate         (new_uri(LV2_CORE__GatePlugin)),

  311.           class_generator    (new_uri(LV2_CORE__GeneratorPlugin)),

  312.           class_highpass     (new_uri(LV2_CORE__HighpassPlugin)),

  313.           class_instrument   (new_uri(LV2_CORE__InstrumentPlugin)),

  314.           class_limiter      (new_uri(LV2_CORE__LimiterPlugin)),

  315.           class_lowpass      (new_uri(LV2_CORE__LowpassPlugin)),

  316.           class_mixer        (new_uri(LV2_CORE__MixerPlugin)),

  317.           class_modulator    (new_uri(LV2_CORE__ModulatorPlugin)),

  318.           class_multiEQ      (new_uri(LV2_CORE__MultiEQPlugin)),

  319.           class_oscillator   (new_uri(LV2_CORE__OscillatorPlugin)),

  320.           class_paraEQ       (new_uri(LV2_CORE__ParaEQPlugin)),

  321.           class_phaser       (new_uri(LV2_CORE__PhaserPlugin)),

  322.           class_pitch        (new_uri(LV2_CORE__PitchPlugin)),

  323.           class_reverb       (new_uri(LV2_CORE__ReverbPlugin)),

  324.           class_simulator    (new_uri(LV2_CORE__SimulatorPlugin)),

  325.           class_spatial      (new_uri(LV2_CORE__SpatialPlugin)),

  326.           class_spectral     (new_uri(LV2_CORE__SpectralPlugin)),

  327.           class_utility      (new_uri(LV2_CORE__UtilityPlugin)),

  328.           class_waveshaper   (new_uri(LV2_CORE__WaveshaperPlugin)),

  329. 

  330.           port_input         (new_uri(LV2_CORE__InputPort)),

  331.           port_output        (new_uri(LV2_CORE__OutputPort)),

  332.           port_control       (new_uri(LV2_CORE__ControlPort)),

  333.           port_audio         (new_uri(LV2_CORE__AudioPort)),

  334.           port_cv            (new_uri(LV2_CORE__CVPort)),

  335.           port_atom          (new_uri(LV2_ATOM__AtomPort)),

  336.           port_event         (new_uri(LV2_EVENT__EventPort)),

  337.           port_midi          (new_uri(LV2_MIDI_LL__MidiPort)),

  338. 

  339.           pprop_optional     (new_uri(LV2_CORE__connectionOptional)),

  340.           pprop_enumeration  (new_uri(LV2_CORE__enumeration)),

  341.           pprop_integer      (new_uri(LV2_CORE__integer)),

  342.           pprop_sampleRate   (new_uri(LV2_CORE__sampleRate)),

  343.           pprop_toggled      (new_uri(LV2_CORE__toggled)),

  344.           pprop_artifacts    (new_uri(LV2_PORT_PROPS__causesArtifacts)),

  345.           pprop_continuousCV (new_uri(LV2_PORT_PROPS__continuousCV)),

  346.           pprop_discreteCV   (new_uri(LV2_PORT_PROPS__discreteCV)),

  347.           pprop_expensive    (new_uri(LV2_PORT_PROPS__expensive)),

  348.           pprop_strictBounds (new_uri(LV2_PORT_PROPS__hasStrictBounds)),

  349.           pprop_logarithmic  (new_uri(LV2_PORT_PROPS__logarithmic)),

  350.           pprop_notAutomatic (new_uri(LV2_PORT_PROPS__notAutomatic)),

  351.           pprop_notOnGUI     (new_uri(LV2_PORT_PROPS__notOnGUI)),

  352.           pprop_trigger      (new_uri(LV2_PORT_PROPS__trigger)),

  353.           pprop_nonAutomable (new_uri(LV2_KXSTUDIO_PROPERTIES__NonAutomable)),

  354. 

  355.           unit_name          (new_uri(LV2_UNITS__name)),

  356.           unit_render        (new_uri(LV2_UNITS__render)),

  357.           unit_symbol        (new_uri(LV2_UNITS__symbol)),

  358.           unit_unit          (new_uri(LV2_UNITS__unit)),

  359. 

  360.           ui_gtk2            (new_uri(LV2_UI__GtkUI)),

  361.           ui_gtk3            (new_uri(LV2_UI__Gtk3UI)),

  362.           ui_qt4             (new_uri(LV2_UI__Qt4UI)),

  363.           ui_qt5             (new_uri(LV2_UI__Qt5UI)),

  364.           ui_cocoa           (new_uri(LV2_UI__CocoaUI)),

  365.           ui_windows         (new_uri(LV2_UI__WindowsUI)),

  366.           ui_x11             (new_uri(LV2_UI__X11UI)),

  367.           ui_external        (new_uri(LV2_EXTERNAL_UI__Widget)),

  368.           ui_externalOld     (new_uri(LV2_EXTERNAL_UI_DEPRECATED_URI)),

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

  370. 

  371.           atom_bufferType    (new_uri(LV2_ATOM__bufferType)),

  372.           atom_sequence      (new_uri(LV2_ATOM__Sequence)),

  373.           atom_supports      (new_uri(LV2_ATOM__supports)),

  374. 

  375.           preset_preset      (new_uri(LV2_PRESETS__Preset)),

  376. 

  377.           state_state        (new_uri(LV2_STATE__state)),

  378. 

  379.           ui_portNotif       (new_uri(LV2_UI__portNotification)),

  380.           ui_protocol        (new_uri(LV2_UI__protocol)),

  381. 

  382.           value_default      (new_uri(LV2_CORE__default)),

  383.           value_minimum      (new_uri(LV2_CORE__minimum)),

  384.           value_maximum      (new_uri(LV2_CORE__maximum)),

  385. 

  386.           rz_asLargeAs       (new_uri(LV2_RESIZE_PORT__asLargeAs)),

  387.           rz_minSize         (new_uri(LV2_RESIZE_PORT__minimumSize)),

  388. 

  389.           midi_event         (new_uri(LV2_MIDI__MidiEvent)),

  390.           patch_message      (new_uri(LV2_PATCH__Message)),

  391.           time_position      (new_uri(LV2_TIME__Position)),

  392. 

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

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

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

  396. 

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

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

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

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

  401. 

  402.           needsInit(true),

  403.           allPlugins(nullptr),

  404.           cachedPlugins(nullptr),

  405.           pluginCount(0) {}

  406. 

  407.     ~Lv2WorldClass() override

  408.     {

  409.         pluginCount = 0;

  410.         allPlugins = nullptr;

  411. 

  412.         if (cachedPlugins != nullptr)

  413.         {

  414.             delete[] cachedPlugins;

  415.             cachedPlugins = nullptr;

  416.         }

  417.     }

  418. 

  419.     // FIXME - remove this

  420.     static Lv2WorldClass& getInstance()

  421.     {

  422.         static Lv2WorldClass lv2World;

  423.         return lv2World;

  424.     }

  425. 

  426.     void initIfNeeded(const char* LV2_PATH)

  427.     {

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

  429.         {

  430.             static const char* const DEFAULT_LV2_PATH = LILV_DEFAULT_LV2_PATH;

  431.             LV2_PATH = DEFAULT_LV2_PATH;

  432.         }

  433. 

  434.         if (! needsInit)

  435.             return;

  436. 

  437.         needsInit = false;

  438. 

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

  440. 

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

  442.         CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr,);

  443. 

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

  445.         {

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

  447.             carla_zeroPointers(cachedPlugins, pluginCount+1);

  448. 

  449.             int i = 0;

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

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

  452.         }

  453.     }

  454. 

  455.     void load_bundle(const char* const bundle)

  456.     {

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

  458.         CARLA_SAFE_ASSERT_RETURN(needsInit,);

  459. 

  460.         needsInit = false;

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

  462. 

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

  464.         CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr,);

  465. 

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

  467.         {

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

  469.             carla_zeroPointers(cachedPlugins, pluginCount+1);

  470. 

  471.             int i = 0;

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

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

  474.         }

  475.     }

  476. 

  477.     uint getPluginCount() const

  478.     {

  479.         CARLA_SAFE_ASSERT_RETURN(! needsInit, 0);

  480. 

  481.         return pluginCount;

  482.     }

  483. 

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

  485.     {

  486.         CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);

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

  488.         CARLA_SAFE_ASSERT_RETURN(index < pluginCount, nullptr);

  489. 

  490.         return cachedPlugins[index];

  491.     }

  492. 

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

  494.     {

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

  496.         CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);

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

  498. 

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

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

  501. 

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

  503.         lilv_node_free(uriNode);

  504. 

  505.         return cPlugin;

  506.     }

  507. 

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

  509.     {

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

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

  512.         CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);

  513. 

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

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

  516. 

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

  518. 

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

  520.         lilv_node_free(uriNode);

  521. 

  522.         return cState;

  523.     }

  524. 

  525.     CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION

  526.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2WorldClass)

  527. };

  528. 

  529. // --------------------------------------------------------------------------------------------------------------------

  530. // Our LV2 Plugin base class

  531. 

  532. #if defined(__clang__)

  533. # pragma clang diagnostic push

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

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

  536. # pragma GCC diagnostic push

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

  538. #endif

  539. template<class TimeInfoStruct>

  540. class Lv2PluginBaseClass : public LV2_External_UI_Widget_Compat

  541. {

  542. #if defined(__clang__)

  543. # pragma clang diagnostic pop

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

  545. # pragma GCC diagnostic pop

  546. #endif

  547. public:

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

  549.         : fIsActive(false),

  550.           fIsOffline(false),

  551.           fUsingNominal(false),

  552.           fBufferSize(0),

  553.           fSampleRate(sampleRate),

  554.           fUridMap(nullptr),

  555.           fTimeInfo(),

  556.           fLastPositionData(),

  557.           fURIs(),

  558.           fUI()

  559.     {

  560.         run  = extui_run;

  561.         show = extui_show;

  562.         hide = extui_hide;

  563. 

  564.         if (fSampleRate < 1.0)

  565.         {

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

  567.             return;

  568.         }

  569. 

  570.         const LV2_Options_Option*  options   = nullptr;

  571.         const LV2_URID_Map*        uridMap   = nullptr;

  572.         const LV2_URID_Unmap*      uridUnmap = nullptr;

  573. 

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

  575.         {

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

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

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

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

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

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

  582.         }

  583. 

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

  585.         {

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

  587.             return;

  588.         }

  589. 

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

  591.         {

  592.             if (uridUnmap != nullptr) {

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

  594.             }

  595. 

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

  597.             {

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

  599.                 {

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

  601.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  602. 

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

  604.                     fUsingNominal = true;

  605.                 }

  606.                 else

  607.                 {

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

  609.                 }

  610.                 break;

  611.             }

  612. 

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

  614.             {

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

  616.                 {

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

  618.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  619. 

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

  621.                 }

  622.                 else

  623.                 {

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

  625.                 }

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

  627.             }

  628.         }

  629. 

  630.         if (fBufferSize == 0)

  631.         {

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

  633.             //return;

  634.             // as testing, continue for now

  635.             fBufferSize = 1024;

  636.         }

  637. 

  638.         fUridMap = uridMap;

  639.         fURIs.map(uridMap);

  640. 

  641.         carla_zeroStruct(fTimeInfo);

  642.         carla_zeroStruct(fLastPositionData);

  643.     }

  644. 

  645.     virtual ~Lv2PluginBaseClass() {}

  646. 

  647.     bool loadedInProperHost() const noexcept

  648.     {

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

  650.     }

  651. 

  652.     // ----------------------------------------------------------------------------------------------------------------

  653. 

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

  655.     {

  656.         fPorts.connectPort(port, dataLocation);

  657.     }

  658. 

  659.     bool lv2_pre_run(const uint32_t frames)

  660.     {

  661.         CARLA_SAFE_ASSERT_RETURN(fIsActive, false);

  662. 

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

  664. 

  665.         // cache midi events and time information first

  666.         if (fPorts.usesTime)

  667.         {

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

  669.             {

  670.                 if (event == nullptr)

  671.                     continue;

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

  673.                     continue;

  674. 

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

  676. 

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

  678.                     continue;

  679. 

  680.                 LV2_Atom* bar     = nullptr;

  681.                 LV2_Atom* barBeat = nullptr;

  682.                 LV2_Atom* beatUnit = nullptr;

  683.                 LV2_Atom* beatsPerBar = nullptr;

  684.                 LV2_Atom* beatsPerMinute = nullptr;

  685.                 LV2_Atom* frame = nullptr;

  686.                 LV2_Atom* speed = nullptr;

  687.                 LV2_Atom* ticksPerBeat = nullptr;

  688. 

  689.                 lv2_atom_object_get(obj,

  690.                                     fURIs.timeBar, &bar,

  691.                                     fURIs.timeBarBeat, &barBeat,

  692.                                     fURIs.timeBeatUnit, &beatUnit,

  693.                                     fURIs.timeBeatsPerBar, &beatsPerBar,

  694.                                     fURIs.timeBeatsPerMinute, &beatsPerMinute,

  695.                                     fURIs.timeFrame, &frame,

  696.                                     fURIs.timeSpeed, &speed,

  697.                                     fURIs.timeTicksPerBeat, &ticksPerBeat,

  698.                                     0);

  699. 

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

  701.                 if (ticksPerBeat != nullptr)

  702.                 {

  703.                     double ticksPerBeatValue = -1.0;

  704. 

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

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

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

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

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

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

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

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

  713.                     else

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

  715. 

  716.                     if (ticksPerBeatValue > 0.0)

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

  718.                     else

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

  720.                 }

  721. 

  722.                 // same

  723.                 if (speed != nullptr)

  724.                 {

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

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

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

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

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

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

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

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

  733.                     else

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

  735. 

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

  737. 

  738.                     if (fTimeInfo.playing && fLastPositionData.beatsPerMinute > 0.0f)

  739.                     {

  740.                         fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute*

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

  742.                     }

  743.                 }

  744. 

  745.                 if (bar != nullptr)

  746.                 {

  747.                     int64_t barValue = -1;

  748. 

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

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

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

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

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

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

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

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

  757.                     else

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

  759. 

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

  761.                     {

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

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

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

  765.                     }

  766.                     else

  767.                     {

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

  769.                     }

  770.                 }

  771. 

  772.                 if (barBeat != nullptr)

  773.                 {

  774.                     double barBeatValue = -1.0;

  775. 

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

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

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

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

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

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

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

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

  784.                     else

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

  786. 

  787.                     if (barBeatValue >= 0.0)

  788.                     {

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

  790. 

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

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

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

  794.                     }

  795.                     else

  796.                     {

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

  798.                     }

  799.                 }

  800. 

  801.                 if (beatUnit != nullptr)

  802.                 {

  803.                     int64_t beatUnitValue = -1;

  804. 

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

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

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

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

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

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

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

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

  813.                     else

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

  815. 

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

  817.                     {

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

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

  820.                     }

  821.                     else

  822.                     {

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

  824.                     }

  825.                 }

  826. 

  827.                 if (beatsPerBar != nullptr)

  828.                 {

  829.                     float beatsPerBarValue = -1.0f;

  830. 

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

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

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

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

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

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

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

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

  839.                     else

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

  841. 

  842.                     if (beatsPerBarValue > 0.0f)

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

  844.                     else

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

  846.                 }

  847. 

  848.                 if (beatsPerMinute != nullptr)

  849.                 {

  850.                     double beatsPerMinuteValue = -1.0;

  851. 

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

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

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

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

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

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

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

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

  860.                     else

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

  862. 

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

  864.                     {

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

  866. 

  867.                         if (carla_isNotZero(fLastPositionData.speed))

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

  869.                     }

  870.                     else

  871.                     {

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

  873.                     }

  874.                 }

  875. 

  876.                 if (frame != nullptr)

  877.                 {

  878.                     int64_t frameValue = -1;

  879. 

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

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

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

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

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

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

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

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

  888.                     else

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

  890. 

  891.                     if (frameValue >= 0)

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

  893.                     else

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

  895.                 }

  896. 

  897.                 fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat*

  898.                                               fTimeInfo.bbt.beatsPerBar*

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

  900. 

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

  902.                                         fLastPositionData.beatUnit > 0 &&

  903.                                         fLastPositionData.beatsPerBar > 0.0f);

  904.             }

  905.         }

  906. 

  907.         // Check for updated parameters

  908.         float curValue;

  909. 

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

  911.         {

  912.             if (fPorts.paramsOut[i])

  913.                 continue;

  914. 

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

  916. 

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

  918. 

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

  920.                 continue;

  921. 

  922.             fPorts.paramsLast[i] = curValue;

  923.             handleParameterValueChanged(i, curValue);

  924.         }

  925. 

  926.         if (frames == 0)

  927.             return false;

  928. 

  929.         // init midi out data

  930.         if (fPorts.numMidiOuts > 0)

  931.         {

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

  933.             {

  934.                 LV2_Atom_Sequence* const seq(fPorts.midiOuts[i]);

  935.                 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);

  936. 

  937.                 fPorts.midiOutData[i].capacity = seq->atom.size;

  938.                 fPorts.midiOutData[i].offset   = 0;

  939. 

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

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

  942.                 seq->body.unit = 0;

  943.                 seq->body.pad  = 0;

  944.             }

  945.         }

  946. 

  947.         return true;

  948.     }

  949. 

  950.     void lv2_post_run(const uint32_t frames)

  951.     {

  952.         // update timePos for next callback

  953. 

  954.         if (carla_isZero(fLastPositionData.speed))

  955.             return;

  956. 

  957.         if (fLastPositionData.speed > 0.0)

  958.         {

  959.             // playing forwards

  960.             fLastPositionData.frame += frames;

  961.         }

  962.         else

  963.         {

  964.             // playing backwards

  965.             if (frames >= fLastPositionData.frame)

  966.                 fLastPositionData.frame = 0;

  967.             else

  968.                 fLastPositionData.frame -= frames;

  969.         }

  970. 

  971.         fTimeInfo.frame = fLastPositionData.frame;

  972. 

  973.         if (fTimeInfo.bbt.valid)

  974.         {

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

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

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

  978. 

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

  980.             {

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

  982.                                                       fLastPositionData.beatsPerBar);

  983. 

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

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

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

  987. 

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

  989.                 {

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

  991.                                                             fLastPositionData.beatsPerBar);

  992. 

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

  994.                     {

  995.                         fLastPositionData.bar   = 0;

  996.                         fLastPositionData.bar_f = 0.0f;

  997.                     }

  998.                     else

  999.                     {

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

  1001.                     }

  1002. 

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

  1004. 

  1005.                     fTimeInfo.bbt.barStartTick = fTimeInfo.bbt.ticksPerBeat *

  1006.                                                  fTimeInfo.bbt.beatsPerBar *

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

  1008.                 }

  1009.             }

  1010.         }

  1011.     }

  1012. 

  1013.     // ----------------------------------------------------------------------------------------------------------------

  1014. 

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

  1016.     {

  1017.         // currently unused

  1018.         return LV2_OPTIONS_SUCCESS;

  1019.     }

  1020. 

  1021.     uint32_t lv2_set_options(const LV2_Options_Option* const options)

  1022.     {

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

  1024.         {

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

  1026.             {

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

  1028.                 {

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

  1030.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  1031. 

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

  1033. 

  1034.                     if (fBufferSize != newBufferSize)

  1035.                     {

  1036.                         fBufferSize = newBufferSize;

  1037.                         handleBufferSizeChanged(newBufferSize);

  1038.                     }

  1039.                 }

  1040.                 else

  1041.                 {

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

  1043.                 }

  1044.             }

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

  1046.             {

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

  1048.                 {

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

  1050.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0);

  1051. 

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

  1053. 

  1054.                     if (fBufferSize != newBufferSize)

  1055.                     {

  1056.                         fBufferSize = newBufferSize;

  1057.                         handleBufferSizeChanged(newBufferSize);

  1058.                     }

  1059.                 }

  1060.                 else

  1061.                 {

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

  1063.                 }

  1064.             }

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

  1066.             {

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

  1068.                 {

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

  1070.                     CARLA_SAFE_ASSERT_CONTINUE(value > 0.0);

  1071. 

  1072.                     if (carla_isNotEqual(fSampleRate, value))

  1073.                     {

  1074.                         fSampleRate = value;

  1075.                         handleSampleRateChanged(value);

  1076.                     }

  1077.                 }

  1078.                 else

  1079.                 {

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

  1081.                 }

  1082.             }

  1083.         }

  1084. 

  1085.         return LV2_OPTIONS_SUCCESS;

  1086.     }

  1087. 

  1088.     // ----------------------------------------------------------------------------------------------------------------

  1089. 

  1090.     int lv2ui_idle() const

  1091.     {

  1092.         if (! fUI.isVisible)

  1093.             return 1;

  1094. 

  1095.         handleUiRun();

  1096.         return 0;

  1097.     }

  1098. 

  1099.     int lv2ui_show()

  1100.     {

  1101.         handleUiShow();

  1102.         return 0;

  1103.     }

  1104. 

  1105.     int lv2ui_hide()

  1106.     {

  1107.         handleUiHide();

  1108.         return 0;

  1109.     }

  1110. 

  1111.     void lv2ui_cleanup()

  1112.     {

  1113.         if (fUI.isVisible)

  1114.             handleUiHide();

  1115. 

  1116.         fUI.host = nullptr;

  1117.         fUI.writeFunction = nullptr;

  1118.         fUI.controller = nullptr;

  1119.     }

  1120. 

  1121.     // ----------------------------------------------------------------------------------------------------------------

  1122. 

  1123. protected:

  1124.     virtual void handleUiRun() const = 0;

  1125.     virtual void handleUiShow() = 0;

  1126.     virtual void handleUiHide() = 0;

  1127. 

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

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

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

  1131. 

  1132.     // LV2 host data

  1133.     bool     fIsActive : 1;

  1134.     bool     fIsOffline : 1;

  1135.     bool     fUsingNominal : 1;

  1136.     uint32_t fBufferSize;

  1137.     double   fSampleRate;

  1138. 

  1139.     // LV2 host features

  1140.     const LV2_URID_Map* fUridMap;

  1141. 

  1142.     // Time info stuff

  1143.     TimeInfoStruct fTimeInfo;

  1144. 

  1145.     struct Lv2PositionData {

  1146.         int32_t  bar;

  1147.         float    bar_f;

  1148.         float    barBeat;

  1149.         uint32_t beatUnit;

  1150.         float    beatsPerBar;

  1151.         double   beatsPerMinute;

  1152.         uint64_t frame;

  1153.         double   speed;

  1154.         double   ticksPerBeat;

  1155. 

  1156.         Lv2PositionData()

  1157.             : bar(-1),

  1158.               bar_f(-1.0f),

  1159.               barBeat(-1.0f),

  1160.               beatUnit(0),

  1161.               beatsPerBar(0.0f),

  1162.               beatsPerMinute(-1.0),

  1163.               frame(0),

  1164.               speed(0.0),

  1165.               ticksPerBeat(-1.0) {}

  1166.     } fLastPositionData;

  1167. 

  1168.     void resetTimeInfo()

  1169.     {

  1170.         carla_zeroStruct(fLastPositionData);

  1171.         carla_zeroStruct(fTimeInfo);

  1172. 

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

  1174.         fTimeInfo.bbt.bar   = 1;

  1175.         fTimeInfo.bbt.beat  = 1;

  1176.         fTimeInfo.bbt.beatsPerBar    = 4;

  1177.         fTimeInfo.bbt.beatType       = 4;

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

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

  1180.     }

  1181. 

  1182.     // Port stuff

  1183.     struct Ports {

  1184.         // need to save current state

  1185.         struct MidiOutData {

  1186.             uint32_t capacity;

  1187.             uint32_t offset;

  1188. 

  1189.             MidiOutData()

  1190.                 : capacity(0),

  1191.                   offset(0) {}

  1192.         };

  1193. 

  1194.         // store port info

  1195.         uint32_t indexOffset;

  1196.         uint32_t numAudioIns;

  1197.         uint32_t numAudioOuts;

  1198.         uint32_t numMidiIns;

  1199.         uint32_t numMidiOuts;

  1200.         uint32_t numParams;

  1201.         bool usesTime;

  1202. 

  1203.         // port buffers

  1204.         const LV2_Atom_Sequence** eventsIn;

  1205.         /* */ LV2_Atom_Sequence** midiOuts;

  1206.         /* */ MidiOutData*        midiOutData;

  1207.         const float** audioIns;

  1208.         /* */ float** audioOuts;

  1209.         /* */ float*  freewheel;

  1210. 

  1211.         // cached parameter values

  1212.         float*  paramsLast;

  1213.         float** paramsPtr;

  1214.         bool*   paramsOut;

  1215. 

  1216.         Ports()

  1217.             : indexOffset(0),

  1218.               numAudioIns(0),

  1219.               numAudioOuts(0),

  1220.               numMidiIns(0),

  1221.               numMidiOuts(0),

  1222.               numParams(0),

  1223.               usesTime(false),

  1224.               eventsIn(nullptr),

  1225.               midiOuts(nullptr),

  1226.               midiOutData(nullptr),

  1227.               audioIns(nullptr),

  1228.               audioOuts(nullptr),

  1229.               freewheel(nullptr),

  1230.               paramsLast(nullptr),

  1231.               paramsPtr(nullptr),

  1232.               paramsOut(nullptr) {}

  1233. 

  1234.         ~Ports()

  1235.         {

  1236.             if (eventsIn != nullptr)

  1237.             {

  1238.                 delete[] eventsIn;

  1239.                 eventsIn = nullptr;

  1240.             }

  1241. 

  1242.             if (midiOuts != nullptr)

  1243.             {

  1244.                 delete[] midiOuts;

  1245.                 midiOuts = nullptr;

  1246.             }

  1247. 

  1248.             if (midiOutData != nullptr)

  1249.             {

  1250.                 delete[] midiOutData;

  1251.                 midiOutData = nullptr;

  1252.             }

  1253. 

  1254.             if (audioIns != nullptr)

  1255.             {

  1256.                 delete[] audioIns;

  1257.                 audioIns = nullptr;

  1258.             }

  1259. 

  1260.             if (audioOuts != nullptr)

  1261.             {

  1262.                 delete[] audioOuts;

  1263.                 audioOuts = nullptr;

  1264.             }

  1265. 

  1266.             if (paramsLast != nullptr)

  1267.             {

  1268.                 delete[] paramsLast;

  1269.                 paramsLast = nullptr;

  1270.             }

  1271. 

  1272.             if (paramsPtr != nullptr)

  1273.             {

  1274.                 delete[] paramsPtr;

  1275.                 paramsPtr = nullptr;

  1276.             }

  1277. 

  1278.             if (paramsOut != nullptr)

  1279.             {

  1280.                 delete[] paramsOut;

  1281.                 paramsOut = nullptr;

  1282.             }

  1283.         }

  1284. 

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

  1286.         void init()

  1287.         {

  1288.             if (numMidiIns > 0)

  1289.             {

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

  1291. 

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

  1293.                     eventsIn[i] = nullptr;

  1294.             }

  1295.             else if (usesTime)

  1296.             {

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

  1298.                 eventsIn[0] = nullptr;

  1299.             }

  1300. 

  1301.             if (numMidiOuts > 0)

  1302.             {

  1303.                 midiOuts = new LV2_Atom_Sequence*[numMidiOuts];

  1304.                 midiOutData = new MidiOutData[numMidiOuts];

  1305. 

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

  1307.                     midiOuts[i] = nullptr;

  1308.             }

  1309. 

  1310.             if (numAudioIns > 0)

  1311.             {

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

  1313. 

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

  1315.                     audioIns[i] = nullptr;

  1316.             }

  1317. 

  1318.             if (numAudioOuts > 0)

  1319.             {

  1320.                 audioOuts = new float*[numAudioOuts];

  1321. 

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

  1323.                     audioOuts[i] = nullptr;

  1324.             }

  1325. 

  1326.             if (numParams > 0)

  1327.             {

  1328.                 paramsLast = new float[numParams];

  1329.                 paramsPtr  = new float*[numParams];

  1330.                 paramsOut  = new bool[numParams];

  1331. 

  1332.                 carla_zeroFloats(paramsLast, numParams);

  1333.                 carla_zeroPointers(paramsPtr, numParams);

  1334.                 carla_zeroStructs(paramsOut, numParams);

  1335. 

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

  1337.             }

  1338. 

  1339.             indexOffset  = numAudioIns + numAudioOuts + numMidiOuts;

  1340.             // 1 event port for time if no midi input is used

  1341.             indexOffset += numMidiIns > 0 ? numMidiIns : (usesTime ? 1 : 0);

  1342.             // 1 extra for freewheel port

  1343.             indexOffset += 1;

  1344.         }

  1345. 

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

  1347.         {

  1348.             uint32_t index = 0;

  1349. 

  1350.             if (numMidiIns > 0 || usesTime)

  1351.             {

  1352.                 if (port == index++)

  1353.                 {

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

  1355.                     return;

  1356.                 }

  1357.             }

  1358. 

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

  1360.             {

  1361.                 if (port == index++)

  1362.                 {

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

  1364.                     return;

  1365.                 }

  1366.             }

  1367. 

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

  1369.             {

  1370.                 if (port == index++)

  1371.                 {

  1372.                     midiOuts[i] = (LV2_Atom_Sequence*)dataLocation;

  1373.                     return;

  1374.                 }

  1375.             }

  1376. 

  1377.             if (port == index++)

  1378.             {

  1379.                 freewheel = (float*)dataLocation;

  1380.                 return;

  1381.             }

  1382. 

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

  1384.             {

  1385.                 if (port == index++)

  1386.                 {

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

  1388.                     return;

  1389.                 }

  1390.             }

  1391. 

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

  1393.             {

  1394.                 if (port == index++)

  1395.                 {

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

  1397.                     return;

  1398.                 }

  1399.             }

  1400. 

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

  1402.             {

  1403.                 if (port == index++)

  1404.                 {

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

  1406.                     return;

  1407.                 }

  1408.             }

  1409.         }

  1410. 

  1411.         CARLA_DECLARE_NON_COPY_STRUCT(Ports);

  1412.     } fPorts;

  1413. 

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

  1415.     struct URIDs {

  1416.         LV2_URID atomBlank;

  1417.         LV2_URID atomObject;

  1418.         LV2_URID atomDouble;

  1419.         LV2_URID atomFloat;

  1420.         LV2_URID atomInt;

  1421.         LV2_URID atomLong;

  1422.         LV2_URID atomSequence;

  1423.         LV2_URID atomString;

  1424.         LV2_URID midiEvent;

  1425.         LV2_URID timePos;

  1426.         LV2_URID timeBar;

  1427.         LV2_URID timeBarBeat;

  1428.         LV2_URID timeBeatsPerBar;

  1429.         LV2_URID timeBeatsPerMinute;

  1430.         LV2_URID timeBeatUnit;

  1431.         LV2_URID timeFrame;

  1432.         LV2_URID timeSpeed;

  1433.         LV2_URID timeTicksPerBeat;

  1434. 

  1435.         URIDs()

  1436.             : atomBlank(0),

  1437.               atomObject(0),

  1438.               atomDouble(0),

  1439.               atomFloat(0),

  1440.               atomInt(0),

  1441.               atomLong(0),

  1442.               atomSequence(0),

  1443.               atomString(0),

  1444.               midiEvent(0),

  1445.               timePos(0),

  1446.               timeBar(0),

  1447.               timeBarBeat(0),

  1448.               timeBeatsPerBar(0),

  1449.               timeBeatsPerMinute(0),

  1450.               timeBeatUnit(0),

  1451.               timeFrame(0),

  1452.               timeSpeed(0),

  1453.               timeTicksPerBeat(0) {}

  1454. 

  1455.         void map(const LV2_URID_Map* const uridMap)

  1456.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1475.         }

  1476.     } fURIs;

  1477. 

  1478.     struct UI {

  1479.         const LV2_External_UI_Host* host;

  1480.         LV2UI_Write_Function writeFunction;

  1481.         LV2UI_Controller controller;

  1482.         bool isEmbed;

  1483.         bool isVisible;

  1484. 

  1485.         UI()

  1486.             : host(nullptr),

  1487.               writeFunction(nullptr),

  1488.               controller(nullptr),

  1489.               isEmbed(false),

  1490.               isVisible(false) {}

  1491.     } fUI;

  1492. 

  1493. private:

  1494.     // ----------------------------------------------------------------------------------------------------------------

  1495. 

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

  1497. 

  1498.     static void extui_run(LV2_External_UI_Widget_Compat* handle)

  1499.     {

  1500.         handlePtr->handleUiRun();

  1501.     }

  1502. 

  1503.     static void extui_show(LV2_External_UI_Widget_Compat* handle)

  1504.     {

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

  1506.         handlePtr->handleUiShow();

  1507.     }

  1508. 

  1509.     static void extui_hide(LV2_External_UI_Widget_Compat* handle)

  1510.     {

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

  1512.         handlePtr->handleUiHide();

  1513.     }

  1514. 

  1515.     #undef handlePtr

  1516. 

  1517.     // ----------------------------------------------------------------------------------------------------------------

  1518. 

  1519.     CARLA_DECLARE_NON_COPY_STRUCT(Lv2PluginBaseClass)

  1520. };

  1521. 

  1522. // --------------------------------------------------------------------------------------------------------------------

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

  1524. 

  1525. static inline

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

  1527. {

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

  1529. 

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

  1531. 

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

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

  1534. 

  1535.     Lilv::Plugin lilvPlugin(cPlugin);

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

  1537. 

  1538.     // ----------------------------------------------------------------------------------------------------------------

  1539.     // Set Plugin Type

  1540.     {

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

  1542. 

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

  1544.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1619.         }

  1620. 

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

  1622.     }

  1623. 

  1624.     // ----------------------------------------------------------------------------------------------------------------

  1625.     // Set Plugin Information

  1626.     {

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

  1628. 

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

  1630.         {

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

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

  1633.             lilv_node_free(nameNode);

  1634.         }

  1635. 

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

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

  1638. 

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

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

  1641. 

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

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

  1644. 

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

  1646. 

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

  1648.         {

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

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

  1651.         }

  1652. 

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

  1654.     }

  1655. 

  1656.     // ----------------------------------------------------------------------------------------------------------------

  1657.     // Set Plugin UniqueID

  1658.     {

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

  1660. 

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

  1662.         {

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

  1664. 

  1665.             if (replaceNode.is_uri())

  1666.             {

  1667. #ifdef USE_QT

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

  1669. 

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

  1671.                 {

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

  1673. 

  1674.                     bool ok;

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

  1676. 

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

  1678.                         rdfDescriptor->UniqueID = uniqueId;

  1679.                 }

  1680. #else

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

  1682. 

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

  1684.                 {

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

  1686. 

  1687.                     if (uniqueId > 0)

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

  1689.                 }

  1690. #endif

  1691.             }

  1692.         }

  1693. 

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

  1695.     }

  1696. 

  1697.     // ----------------------------------------------------------------------------------------------------------------

  1698.     // Set Plugin Ports

  1699. 

  1700.     if (lilvPlugin.get_num_ports() > 0)

  1701.     {

  1702.         rdfDescriptor->PortCount = lilvPlugin.get_num_ports();

  1703.         rdfDescriptor->Ports = new LV2_RDF_Port[rdfDescriptor->PortCount];

  1704. 

  1705.         for (uint32_t i = 0; i < rdfDescriptor->PortCount; ++i)

  1706.         {

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

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

  1709. 

  1710.             // --------------------------------------------------------------------------------------------------------

  1711.             // Set Port Information

  1712.             {

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

  1714.                 {

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

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

  1717.                     lilv_node_free(nameNode);

  1718.                 }

  1719. 

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

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

  1722.             }

  1723. 

  1724.             // --------------------------------------------------------------------------------------------------------

  1725.             // Set Port Mode and Type

  1726.             {

  1727.                 // Input or Output

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

  1729.                     rdfPort->Types |= LV2_PORT_INPUT;

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

  1731.                     rdfPort->Types |= LV2_PORT_OUTPUT;

  1732.                 else

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

  1734. 

  1735.                 // Data Type

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

  1737.                 {

  1738.                     rdfPort->Types |= LV2_PORT_CONTROL;

  1739.                 }

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

  1741.                 {

  1742.                     rdfPort->Types |= LV2_PORT_AUDIO;

  1743.                 }

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

  1745.                 {

  1746.                     rdfPort->Types |= LV2_PORT_CV;

  1747.                 }

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

  1749.                 {

  1750.                     rdfPort->Types |= LV2_PORT_ATOM;

  1751. 

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

  1753. 

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

  1755.                     {

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

  1757.                         CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  1758. 

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

  1760.                             rdfPort->Types |= LV2_PORT_ATOM_SEQUENCE;

  1761.                         else

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

  1763.                     }

  1764. 

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

  1766. 

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

  1768.                     {

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

  1770.                         CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());

  1771. 

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

  1773.                             rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;

  1774. 

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

  1776.                             rdfPort->Types |= LV2_PORT_DATA_PATCH_MESSAGE;

  1777. 

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

  1779.                             rdfPort->Types |= LV2_PORT_DATA_TIME_POSITION;

  1780. 

  1781. #if 0

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

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

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

  1785. #endif

  1786.                     }

  1787. 

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

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

  1790.                 }

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

  1792.                 {

  1793.                     rdfPort->Types |= LV2_PORT_EVENT;

  1794.                     bool supported  = false;

  1795. 

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

  1797.                     {

  1798.                         rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;

  1799.                         supported = true;

  1800.                     }

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

  1802.                     {

  1803.                         rdfPort->Types |= LV2_PORT_DATA_PATCH_MESSAGE;

  1804.                         supported = true;

  1805.                     }

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

  1807.                     {

  1808.                         rdfPort->Types |= LV2_PORT_DATA_TIME_POSITION;

  1809.                         supported = true;

  1810.                     }

  1811. 

  1812.                     if (! supported)

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

  1814.                 }

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

  1816.                 {

  1817.                     rdfPort->Types |= LV2_PORT_MIDI_LL;

  1818.                     rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;

  1819.                 }

  1820.                 else

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

  1822.             }

  1823. 

  1824.             // --------------------------------------------------------------------------------------------------------

  1825.             // Set Port Properties

  1826.             {

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

  1828.                     rdfPort->Properties |= LV2_PORT_OPTIONAL;

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

  1830.                     rdfPort->Properties |= LV2_PORT_ENUMERATION;

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

  1832.                     rdfPort->Properties |= LV2_PORT_INTEGER;

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

  1834.                     rdfPort->Properties |= LV2_PORT_SAMPLE_RATE;

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

  1836.                     rdfPort->Properties |= LV2_PORT_TOGGLED;

  1837. 

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

  1839.                     rdfPort->Properties |= LV2_PORT_CAUSES_ARTIFACTS;

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

  1841.                     rdfPort->Properties |= LV2_PORT_CONTINUOUS_CV;

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

  1843.                     rdfPort->Properties |= LV2_PORT_DISCRETE_CV;

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

  1845.                     rdfPort->Properties |= LV2_PORT_EXPENSIVE;

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

  1847.                     rdfPort->Properties |= LV2_PORT_STRICT_BOUNDS;

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

  1849.                     rdfPort->Properties |= LV2_PORT_LOGARITHMIC;

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

  1851.                     rdfPort->Properties |= LV2_PORT_NOT_AUTOMATIC;

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

  1853.                     rdfPort->Properties |= LV2_PORT_NOT_ON_GUI;

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

  1855.                     rdfPort->Properties |= LV2_PORT_TRIGGER;

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

  1857.                     rdfPort->Properties |= LV2_PORT_NON_AUTOMABLE;

  1858. 

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

  1860.                     rdfPort->Designation = LV2_PORT_DESIGNATION_LATENCY;

  1861. 

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

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

  1864.                 {

  1865.                     const Lilv::Node oldPropArtifacts(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#causesArtifacts"));

  1866.                     const Lilv::Node oldPropContinuousCV(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#continuousCV"));

  1867.                     const Lilv::Node oldPropDiscreteCV(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#discreteCV"));

  1868.                     const Lilv::Node oldPropExpensive(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#expensive"));

  1869.                     const Lilv::Node oldPropStrictBounds(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#hasStrictBounds"));

  1870.                     const Lilv::Node oldPropLogarithmic(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#logarithmic"));

  1871.                     const Lilv::Node oldPropNotAutomatic(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#notAutomatic"));

  1872.                     const Lilv::Node oldPropNotOnGUI(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#notOnGUI"));

  1873.                     const Lilv::Node oldPropTrigger(lv2World.new_uri("http://lv2plug.in/ns/dev/extportinfo#trigger"));

  1874. 

  1875.                     if (lilvPort.has_property(oldPropArtifacts))

  1876.                     {

  1877.                         rdfPort->Properties |= LV2_PORT_CAUSES_ARTIFACTS;

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

  1879.                     }

  1880.                     if (lilvPort.has_property(oldPropContinuousCV))

  1881.                     {

  1882.                         rdfPort->Properties |= LV2_PORT_CONTINUOUS_CV;

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

  1884.                     }

  1885.                     if (lilvPort.has_property(oldPropDiscreteCV))

  1886.                     {

  1887.                         rdfPort->Properties |= LV2_PORT_DISCRETE_CV;

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

  1889.                     }

  1890.                     if (lilvPort.has_property(oldPropExpensive))

  1891.                     {

  1892.                         rdfPort->Properties |= LV2_PORT_EXPENSIVE;

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

  1894.                     }

  1895.                     if (lilvPort.has_property(oldPropStrictBounds))

  1896.                     {

  1897.                         rdfPort->Properties |= LV2_PORT_STRICT_BOUNDS;

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

  1899.                     }

  1900.                     if (lilvPort.has_property(oldPropLogarithmic))

  1901.                     {

  1902.                         rdfPort->Properties |= LV2_PORT_LOGARITHMIC;

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

  1904.                     }

  1905.                     if (lilvPort.has_property(oldPropNotAutomatic))

  1906.                     {

  1907.                         rdfPort->Properties |= LV2_PORT_NOT_AUTOMATIC;

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

  1909.                     }

  1910.                     if (lilvPort.has_property(oldPropNotOnGUI))

  1911.                     {

  1912.                         rdfPort->Properties |= LV2_PORT_NOT_ON_GUI;

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

  1914.                     }

  1915.                     if (lilvPort.has_property(oldPropTrigger))

  1916.                     {

  1917.                         rdfPort->Properties |= LV2_PORT_TRIGGER;

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

  1919.                     }

  1920.                 }

  1921.             }

  1922. 

  1923.             // --------------------------------------------------------------------------------------------------------

  1924.             // Set Port Designation

  1925.             {

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

  1927.                 {

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

  1929.                     {

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

  1931.                             rdfPort->Designation = LV2_PORT_DESIGNATION_CONTROL;

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

  1933.                             rdfPort->Designation = LV2_PORT_DESIGNATION_ENABLED;

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

  1935.                             rdfPort->Designation = LV2_PORT_DESIGNATION_FREEWHEELING;

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

  1937.                             rdfPort->Designation = LV2_PORT_DESIGNATION_LATENCY;

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

  1939.                             rdfPort->Designation = LV2_PORT_DESIGNATION_SAMPLE_RATE;

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

  1941.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BAR;

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

  1943.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BAR_BEAT;

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

  1945.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEAT;

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

  1947.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEAT_UNIT;

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

  1949.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR;

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

  1951.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE;

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

  1953.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_FRAME;

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

  1955.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND;

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

  1957.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_SPEED;

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

  1959.                             rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_TICKS_PER_BEAT;

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

  1961.                             pass();

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

  1963.                             pass();

  1964.                         else

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

  1966.                     }

  1967.                     lilv_node_free(designationNode);

  1968.                 }

  1969.             }

  1970. 

  1971.             // --------------------------------------------------------------------------------------------------------

  1972.             // Set Port MIDI Map

  1973.             {

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

  1975.                 {

  1976.                     if (lilv_node_is_blank(midiMapNode))

  1977.                     {

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

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

  1980. 

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

  1982.                         {

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

  1984.                             {

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

  1986.                                     rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_CC;

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

  1988.                                     rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_NRPN;

  1989.                                 else

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

  1991. 

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

  1993.                             }

  1994.                         }

  1995. 

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

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

  1998.                     }

  1999. 

  2000.                     lilv_node_free(midiMapNode);

  2001.                 }

  2002. 

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

  2004.             }

  2005. 

  2006.             // --------------------------------------------------------------------------------------------------------

  2007.             // Set Port Points

  2008.             {

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

  2010.                 {

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

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

  2013.                     lilv_node_free(defNode);

  2014.                 }

  2015. 

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

  2017.                 {

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

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

  2020.                     lilv_node_free(minNode);

  2021.                 }

  2022. 

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

  2024.                 {

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

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

  2027.                     lilv_node_free(maxNode);

  2028.                 }

  2029.             }

  2030. 

  2031.             // --------------------------------------------------------------------------------------------------------

  2032.             // Set Port Unit

  2033.             {

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

  2035.                 {

  2036.                     if (lilv_node_is_uri(unitUnitNode))

  2037.                     {

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

  2039.                         {

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

  2041. 

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

  2043.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_BAR;

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

  2045.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_BEAT;

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

  2047.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_BPM;

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

  2049.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_CENT;

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

  2051.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_CM;

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

  2053.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_COEF;

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

  2055.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_DB;

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

  2057.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_DEGREE;

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

  2059.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_FRAME;

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

  2061.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_HZ;

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

  2063.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_INCH;

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

  2065.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_KHZ;

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

  2067.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_KM;

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

  2069.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_M;

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

  2071.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MHZ;

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

  2073.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MIDINOTE;

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

  2075.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MILE;

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

  2077.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MIN;

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

  2079.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MM;

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

  2081.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_MS;

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

  2083.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_OCT;

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

  2085.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_PC;

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

  2087.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_S;

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

  2089.                                 rdfPort->Unit.Unit = LV2_PORT_UNIT_SEMITONE;

  2090.                             else

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

  2092.                         }

  2093.                     }

  2094. 

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

  2096.                     {

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

  2098.                         {

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

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

  2101.                         }

  2102.                         lilv_node_free(unitNameNode);

  2103.                     }

  2104. 

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

  2106.                     {

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

  2108.                         {

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

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

  2111.                         }

  2112.                         lilv_node_free(unitRenderNode);

  2113.                     }

  2114. 

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

  2116.                     {

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

  2118.                         {

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

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

  2121.                         }

  2122.                         lilv_node_free(unitSymbolNode);

  2123.                     }

  2124. 

  2125.                     lilv_node_free(unitUnitNode);

  2126.                 }

  2127.             }

  2128. 

  2129.             // --------------------------------------------------------------------------------------------------------

  2130.             // Set Port Minimum Size

  2131.             {

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

  2133.                 {

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

  2135. 

  2136.                     if (minimumSize > 0)

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

  2138.                     else

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

  2140. 

  2141.                     lilv_node_free(minimumSizeNode);

  2142.                 }

  2143.             }

  2144. 

  2145.             // --------------------------------------------------------------------------------------------------------

  2146.             // Set Port Scale Points

  2147.             {

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

  2149. 

  2150.                 if (lilvScalePoints.size() > 0)

  2151.                 {

  2152.                     rdfPort->ScalePointCount = lilvScalePoints.size();

  2153.                     rdfPort->ScalePoints = new LV2_RDF_PortScalePoint[rdfPort->ScalePointCount];

  2154. 

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

  2156.                     LilvScalePointMap sortedpoints;

  2157. 

  2158.                     LILV_FOREACH(scale_points, it, lilvScalePoints)

  2159.                     {

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

  2161. 

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

  2163. 

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

  2165.                         {

  2166.                             const double valueid = lilv_node_as_float(valuenode);

  2167.                             sortedpoints[valueid] = lilvScalePoint.me;

  2168.                         }

  2169.                     }

  2170. 

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

  2172.                     uint32_t h = 0;

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

  2174.                     {

  2175.                         CARLA_SAFE_ASSERT_BREAK(h < rdfPort->ScalePointCount);

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

  2177. 

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

  2179. 

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

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

  2182. 

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

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

  2185.                     }

  2186.                 }

  2187. 

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

  2189.             }

  2190.         }

  2191.     }

  2192. 

  2193.     // ----------------------------------------------------------------------------------------------------------------

  2194.     // Set Plugin Presets

  2195. 

  2196.     if (loadPresets)

  2197.     {

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

  2199. 

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

  2201.         {

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

  2203. #ifdef USE_QT

  2204.             QStringList presetListURIs;

  2205. 

  2206.             LILV_FOREACH(nodes, it, presetNodes)

  2207.             {

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

  2209. 

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

  2211. 

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

  2213.                     presetListURIs.append(presetURI);

  2214.             }

  2215. 

  2216.             presetListURIs.sort();

  2217. 

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

  2219. #else

  2220.             water::StringArray presetListURIs;

  2221. 

  2222.             LILV_FOREACH(nodes, it, presetNodes)

  2223.             {

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

  2225. 

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

  2227. 

  2228.                 if (presetURI.trim().isNotEmpty())

  2229.                     presetListURIs.addIfNotAlreadyThere(presetURI);

  2230.             }

  2231. 

  2232.             presetListURIs.sortNatural();

  2233. 

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

  2235. #endif

  2236. 

  2237.             // create presets with unique URIs

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

  2239. 

  2240.             // set preset data

  2241.             LILV_FOREACH(nodes, it, presetNodes)

  2242.             {

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

  2244. 

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

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

  2247. 

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

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

  2250. 

  2251.                 // failed, try loading resource

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

  2253.                 {

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

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

  2256.                         continue;

  2257. 

  2258.                     // ok, let's try again

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

  2260.                 }

  2261. 

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

  2263.                 {

  2264. #ifdef USE_QT

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

  2266. #else

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

  2268. #endif

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

  2270. 

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

  2272. 

  2273.                     // ---------------------------------------------------

  2274.                     // Set Preset Information

  2275. 

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

  2277. 

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

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

  2280. 

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

  2282.                 }

  2283.             }

  2284.         }

  2285. 

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

  2287.     }

  2288. 

  2289.     // ----------------------------------------------------------------------------------------------------------------

  2290.     // Set Plugin Features

  2291.     {

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

  2293. 

  2294.         if (lilvFeatureNodes.size() > 0)

  2295.         {

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

  2297. 

  2298.             rdfDescriptor->FeatureCount = lilvFeatureNodes.size();

  2299.             rdfDescriptor->Features = new LV2_RDF_Feature[rdfDescriptor->FeatureCount];

  2300. 

  2301.             uint32_t h = 0;

  2302.             LILV_FOREACH(nodes, it, lilvFeatureNodes)

  2303.             {

  2304.                 CARLA_SAFE_ASSERT_BREAK(h < rdfDescriptor->FeatureCount);

  2305. 

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

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

  2308. 

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

  2310. 

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

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

  2313.                 else

  2314.                     rdfFeature->URI = nullptr;

  2315.             }

  2316. 

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

  2318.         }

  2319. 

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

  2321.     }

  2322. 

  2323.     // ----------------------------------------------------------------------------------------------------------------

  2324.     // Set Plugin Extensions

  2325.     {

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

  2327. 

  2328.         if (lilvExtensionDataNodes.size() > 0)

  2329.         {

  2330.             rdfDescriptor->ExtensionCount = lilvExtensionDataNodes.size();

  2331.             rdfDescriptor->Extensions = new LV2_URI[rdfDescriptor->ExtensionCount];

  2332. 

  2333.             uint32_t h = 0;

  2334.             LILV_FOREACH(nodes, it, lilvExtensionDataNodes)

  2335.             {

  2336.                 CARLA_SAFE_ASSERT_BREAK(h < rdfDescriptor->ExtensionCount);

  2337. 

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

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

  2340. 

  2341.                 if (lilvExtensionDataNode.is_uri())

  2342.                 {

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

  2344.                     {

  2345.                         *rdfExtension = carla_strdup(extURI);

  2346.                         continue;

  2347.                     }

  2348.                 }

  2349.                 *rdfExtension = nullptr;

  2350.             }

  2351. 

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

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

  2354.         }

  2355. 

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

  2357.     }

  2358. 

  2359.     // ----------------------------------------------------------------------------------------------------------------

  2360.     // Set Plugin UIs

  2361.     {

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

  2363. 

  2364.         if (lilvUIs.size() > 0)

  2365.         {

  2366.             rdfDescriptor->UICount = lilvUIs.size();

  2367.             rdfDescriptor->UIs = new LV2_RDF_UI[rdfDescriptor->UICount];

  2368. 

  2369.             uint32_t h = 0;

  2370.             LILV_FOREACH(uis, it, lilvUIs)

  2371.             {

  2372.                 CARLA_SAFE_ASSERT_BREAK(h < rdfDescriptor->UICount);

  2373. 

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

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

  2376. 

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

  2378. 

  2379.                 // ----------------------------------------------------------------------------------------------------

  2380.                 // Set UI Type

  2381. 

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

  2383.                     rdfUI->Type = LV2_UI_GTK2;

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

  2385.                     rdfUI->Type = LV2_UI_GTK3;

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

  2387.                     rdfUI->Type = LV2_UI_QT4;

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

  2389.                     rdfUI->Type = LV2_UI_QT5;

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

  2391.                     rdfUI->Type = LV2_UI_COCOA;

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

  2393.                     rdfUI->Type = LV2_UI_WINDOWS;

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

  2395.                     rdfUI->Type = LV2_UI_X11;

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

  2397.                     rdfUI->Type = LV2_UI_EXTERNAL;

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

  2399.                     rdfUI->Type = LV2_UI_OLD_EXTERNAL;

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

  2401.                     pass();

  2402.                 else

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

  2404. 

  2405.                 // ----------------------------------------------------------------------------------------------------

  2406.                 // Set UI Information

  2407.                 {

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

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

  2410. 

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

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

  2413. 

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

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

  2416.                 }

  2417. 

  2418.                 // ----------------------------------------------------------------------------------------------------

  2419.                 // Set UI Features

  2420.                 {

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

  2422. 

  2423.                     if (lilvFeatureNodes.size() > 0)

  2424.                     {

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

  2426. 

  2427.                         rdfUI->FeatureCount = lilvFeatureNodes.size();

  2428.                         rdfUI->Features = new LV2_RDF_Feature[rdfUI->FeatureCount];

  2429. 

  2430.                         uint32_t h2 = 0;

  2431.                         LILV_FOREACH(nodes, it2, lilvFeatureNodes)

  2432.                         {

  2433.                             CARLA_SAFE_ASSERT_BREAK(h2 < rdfUI->FeatureCount);

  2434. 

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

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

  2437. 

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

  2439. 

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

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

  2442.                             else

  2443.                                 rdfFeature->URI = nullptr;

  2444.                         }

  2445. 

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

  2447.                     }

  2448. 

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

  2450.                 }

  2451. 

  2452.                 // ----------------------------------------------------------------------------------------------------

  2453.                 // Set UI Extensions

  2454.                 {

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

  2456. 

  2457.                     if (lilvExtensionDataNodes.size() > 0)

  2458.                     {

  2459.                         rdfUI->ExtensionCount = lilvExtensionDataNodes.size();

  2460.                         rdfUI->Extensions = new LV2_URI[rdfUI->ExtensionCount];

  2461. 

  2462.                         uint32_t h2 = 0;

  2463.                         LILV_FOREACH(nodes, it2, lilvExtensionDataNodes)

  2464.                         {

  2465.                             CARLA_SAFE_ASSERT_BREAK(h2 < rdfUI->ExtensionCount);

  2466. 

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

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

  2469. 

  2470.                             if (lilvExtensionDataNode.is_uri())

  2471.                             {

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

  2473.                                 {

  2474.                                     *rdfExtension = carla_strdup(extURI);

  2475.                                     continue;

  2476.                                 }

  2477.                             }

  2478.                             *rdfExtension = nullptr;

  2479.                         }

  2480. 

  2481.                         for (uint32_t x2=h2; x2 < rdfUI->ExtensionCount; ++x2)

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

  2483.                     }

  2484. 

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

  2486.                 }

  2487. 

  2488.                 // ----------------------------------------------------------------------------------------------------

  2489.                 // Set UI Port Notifications

  2490.                 {

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

  2492. 

  2493.                     if (portNotifNodes.size() > 0)

  2494.                     {

  2495.                         rdfUI->PortNotificationCount = portNotifNodes.size();

  2496.                         rdfUI->PortNotifications = new LV2_RDF_UI_PortNotification[rdfUI->PortNotificationCount];

  2497. 

  2498.                         carla_stdout("got port notifications!! %u", rdfUI->PortNotificationCount);

  2499. 

  2500.                         uint32_t h2 = 0;

  2501.                         LILV_FOREACH(nodes, it2, portNotifNodes)

  2502.                         {

  2503.                             CARLA_SAFE_ASSERT_BREAK(h2 < rdfUI->PortNotificationCount);

  2504. 

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

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

  2507. 

  2508.                             LilvNode* const symbolNode = lilv_world_get(lv2World.me, portNotifNode,

  2509.                                                                         lv2World.symbol.me, nullptr);

  2510.                             CARLA_SAFE_ASSERT_CONTINUE(symbolNode != nullptr);

  2511. 

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

  2513.                                                                           lv2World.ui_protocol.me, nullptr);

  2514.                             CARLA_SAFE_ASSERT_CONTINUE(protocolNode != nullptr);

  2515. 

  2516.                             CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_string(symbolNode));

  2517.                             CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_uri(protocolNode));

  2518. 

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

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

  2521. 

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

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

  2524. 

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

  2526.                                 rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_FLOAT;

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

  2528.                                 rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_PEAK;

  2529. 

  2530.                             rdfPortNotif->Symbol = carla_strdup_safe(symbol);

  2531.                         }

  2532.                     }

  2533. 

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

  2535.                 }

  2536.             }

  2537.         }

  2538. 

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

  2540.     }

  2541. 

  2542.     return rdfDescriptor;

  2543. }

  2544. 

  2545. // --------------------------------------------------------------------------------------------------------------------

  2546. // Check if we support a plugin port

  2547. 

  2548. static inline

  2549. bool is_lv2_port_supported(const LV2_Property types) noexcept

  2550. {

  2551.     if (LV2_IS_PORT_CONTROL(types))

  2552.         return true;

  2553.     if (LV2_IS_PORT_AUDIO(types))

  2554.         return true;

  2555.     if (LV2_IS_PORT_CV(types))

  2556.         return true;

  2557.     if (LV2_IS_PORT_ATOM_SEQUENCE(types))

  2558.         return true;

  2559.     if (LV2_IS_PORT_EVENT(types))

  2560.         return true;

  2561.     if (LV2_IS_PORT_MIDI_LL(types))

  2562.         return true;

  2563.     return false;

  2564. }

  2565. 

  2566. // --------------------------------------------------------------------------------------------------------------------

  2567. // Check if we support a plugin feature

  2568. 

  2569. static inline

  2570. bool is_lv2_feature_supported(const LV2_URI uri) noexcept

  2571. {

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

  2573. 

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

  2575.         return true;

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

  2577.         return true;

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

  2579.         return true;

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

  2581.         return true;

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

  2583.         return true;

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

  2585.         return true;

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

  2587.         return true;

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

  2589.         return true;

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

  2591.         return true;

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

  2593.         return true;

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

  2595.         return true;

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

  2597.         return true;

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

  2599.         return true;

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

  2601.         return true;

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

  2603.         return true;

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

  2605.         return true;

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

  2607.         return true;

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

  2609.         return true;

  2610.     if (std::strcmp(uri, LV2_URID__map) == 0)

  2611.         return true;

  2612.     if (std::strcmp(uri, LV2_URID__unmap) == 0)

  2613.         return true;

  2614.     if (std::strcmp(uri, LV2_WORKER__schedule) == 0)

  2615.         return true;

  2616.     return false;

  2617. }

  2618. 

  2619. // --------------------------------------------------------------------------------------------------------------------

  2620. // Check if we support a plugin or UI feature

  2621. 

  2622. static inline

  2623. bool is_lv2_ui_feature_supported(const LV2_URI uri) noexcept

  2624. {

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

  2626. 

  2627.     if (is_lv2_feature_supported(uri))

  2628.         return true;

  2629. #ifndef BUILD_BRIDGE_UI

  2630.     if (std::strcmp(uri, LV2_DATA_ACCESS_URI) == 0)

  2631.         return true;

  2632.     if (std::strcmp(uri, LV2_INSTANCE_ACCESS_URI) == 0)

  2633.         return true;

  2634. #endif

  2635.     if (std::strcmp(uri, LV2_UI__fixedSize) == 0)

  2636.         return true;

  2637.     if (std::strcmp(uri, LV2_UI__idleInterface) == 0)

  2638.         return true;

  2639.     if (std::strcmp(uri, LV2_UI__makeResident) == 0)

  2640.         return true;

  2641.     if (std::strcmp(uri, LV2_UI__makeSONameResident) == 0)

  2642.         return true;

  2643.     if (std::strcmp(uri, LV2_UI__noUserResize) == 0)

  2644.         return true;

  2645.     if (std::strcmp(uri, LV2_UI__parent) == 0)

  2646.         return true;

  2647.     if (std::strcmp(uri, LV2_UI__portMap) == 0)

  2648.         return true;

  2649.     if (std::strcmp(uri, LV2_UI__portSubscribe) == 0)

  2650.         return true;

  2651.     if (std::strcmp(uri, LV2_UI__resize) == 0)

  2652.         return true;

  2653.     if (std::strcmp(uri, LV2_UI__touch) == 0)

  2654.         return true;

  2655.     if (std::strcmp(uri, LV2_EXTERNAL_UI__Widget) == 0)

  2656.         return true;

  2657.     if (std::strcmp(uri, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)

  2658.         return true;

  2659.     return false;

  2660. }

  2661. 

  2662. // --------------------------------------------------------------------------------------------------------------------

  2663. 

  2664. #endif // CARLA_LV2_UTILS_HPP_INCLUDED