falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
344 Commits
2 Branches
34MB
Tree: d6ecf2e9c4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd6ecf2e9c4'
${ noResults }
Cadence/c++/carla-includes/carla_lv2.h

1544 lines
61KB
Raw Blame History 

  1. /*

  2.  * Carla common LV2 code

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

  4.  *

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

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

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 COPYING file

  16.  */

  17. 

  18. #ifndef CARLA_LV2_INCLUDES_H

  19. #define CARLA_LV2_INCLUDES_H

  20. 

  21. // TODO - presets

  22. // FIXME - use strings for unit checks

  23. 

  24. #include "lv2/lv2.h"

  25. #include "lv2/atom.h"

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

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

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

  29. #include "lv2/event.h"

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

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

  32. #include "lv2/log.h"

  33. #include "lv2/midi.h"

  34. #include "lv2/patch.h"

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

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

  37. #include "lv2/presets.h"

  38. #include "lv2/state.h"

  39. #include "lv2/time.h"

  40. #include "lv2/ui.h"

  41. #include "lv2/units.h"

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

  43. #include "lv2/urid.h"

  44. #include "lv2/worker.h"

  45. 

  46. #include "lv2/lv2dynparam.h"

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

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

  49. #include "lv2/lv2_external_ui.h"

  50. #include "lv2/lv2_programs.h"

  51. #include "lv2/lv2_rtmempool.h"

  52. 

  53. #include "lv2_rdf.h"

  54. #include "lilv/lilvmm.hpp"

  55. #include "sratom/sratom.h"

  56. 

  57. #include <QtCore/QMap>

  58. #include <QtCore/QString>

  59. #include <QtCore/QStringList>

  60. 

  61. // ------------------------------------------------------------------------------------------------

  62. 

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

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

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

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

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

  68. 

  69. #define LV2_PARAMETERS_URI    "http://lv2plug.in/ns/ext/parameters"

  70. #define LV2_PARAMETERS_PREFIX LV2_PARAMETERS_URI "#"

  71. 

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

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

  74. 

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

  76. 

  77. class Lv2WorldClass : public Lilv::World

  78. {

  79. public:

  80.     Lv2WorldClass() : Lilv::World(),

  81.         port                (new_uri(LV2_CORE__port)),

  82.         symbol              (new_uri(LV2_CORE__symbol)),

  83.         designation         (new_uri(LV2_CORE__designation)),

  84.         freewheeling        (new_uri(LV2_CORE__freeWheeling)),

  85.         reportsLatency      (new_uri(LV2_CORE__reportsLatency)),

  86. 

  87.         class_allpass       (new_uri(LV2_CORE__AllpassPlugin)),

  88.         class_amplifier     (new_uri(LV2_CORE__AmplifierPlugin)),

  89.         class_analyzer      (new_uri(LV2_CORE__AnalyserPlugin)),

  90.         class_bandpass      (new_uri(LV2_CORE__BandpassPlugin)),

  91.         class_chorus        (new_uri(LV2_CORE__ChorusPlugin)),

  92.         class_comb          (new_uri(LV2_CORE__CombPlugin)),

  93.         class_compressor    (new_uri(LV2_CORE__CompressorPlugin)),

  94.         class_constant      (new_uri(LV2_CORE__ConstantPlugin)),

  95.         class_converter     (new_uri(LV2_CORE__ConverterPlugin)),

  96.         class_delay         (new_uri(LV2_CORE__DelayPlugin)),

  97.         class_distortion    (new_uri(LV2_CORE__DistortionPlugin)),

  98.         class_dynamics      (new_uri(LV2_CORE__DynamicsPlugin)),

  99.         class_eq            (new_uri(LV2_CORE__EQPlugin)),

  100.         class_expander      (new_uri(LV2_CORE__ExpanderPlugin)),

  101.         class_filter        (new_uri(LV2_CORE__FilterPlugin)),

  102.         class_flanger       (new_uri(LV2_CORE__FlangerPlugin)),

  103.         class_function      (new_uri(LV2_CORE__FunctionPlugin)),

  104.         class_gate          (new_uri(LV2_CORE__GatePlugin)),

  105.         class_generator     (new_uri(LV2_CORE__GeneratorPlugin)),

  106.         class_highpass      (new_uri(LV2_CORE__HighpassPlugin)),

  107.         class_instrument    (new_uri(LV2_CORE__InstrumentPlugin)),

  108.         class_limiter       (new_uri(LV2_CORE__LimiterPlugin)),

  109.         class_lowpass       (new_uri(LV2_CORE__LowpassPlugin)),

  110.         class_mixer         (new_uri(LV2_CORE__MixerPlugin)),

  111.         class_modulator     (new_uri(LV2_CORE__ModulatorPlugin)),

  112.         class_multi_eq      (new_uri(LV2_CORE__MultiEQPlugin)),

  113.         class_oscillator    (new_uri(LV2_CORE__OscillatorPlugin)),

  114.         class_para_eq       (new_uri(LV2_CORE__ParaEQPlugin)),

  115.         class_phaser        (new_uri(LV2_CORE__PhaserPlugin)),

  116.         class_pitch         (new_uri(LV2_CORE__PitchPlugin)),

  117.         class_reverb        (new_uri(LV2_CORE__ReverbPlugin)),

  118.         class_simulator     (new_uri(LV2_CORE__SimulatorPlugin)),

  119.         class_spatial       (new_uri(LV2_CORE__SpatialPlugin)),

  120.         class_spectral      (new_uri(LV2_CORE__SpectralPlugin)),

  121.         class_utility       (new_uri(LV2_CORE__UtilityPlugin)),

  122.         class_waveshaper    (new_uri(LV2_CORE__WaveshaperPlugin)),

  123. 

  124.         port_input          (new_uri(LV2_CORE__InputPort)),

  125.         port_output         (new_uri(LV2_CORE__OutputPort)),

  126.         port_control        (new_uri(LV2_CORE__ControlPort)),

  127.         port_audio          (new_uri(LV2_CORE__AudioPort)),

  128.         port_cv             (new_uri(LV2_CORE__CVPort)),

  129.         port_atom           (new_uri(LV2_ATOM__AtomPort)),

  130.         port_event          (new_uri(LV2_EVENT__EventPort)),

  131.         port_midi_ll        (new_uri(LV2_MIDI_LL__MidiPort)),

  132. 

  133.         pprop_optional      (new_uri(LV2_CORE__connectionOptional)),

  134.         pprop_enumeration   (new_uri(LV2_CORE__enumeration)),

  135.         pprop_integer       (new_uri(LV2_CORE__integer)),

  136.         pprop_sample_rate   (new_uri(LV2_CORE__sampleRate)),

  137.         pprop_toggled       (new_uri(LV2_CORE__toggled)),

  138.         pprop_artifacts     (new_uri(LV2_PORT_PROPS__causesArtifacts)),

  139.         pprop_continuous_cv (new_uri(LV2_PORT_PROPS__continuousCV)),

  140.         pprop_discrete_cv   (new_uri(LV2_PORT_PROPS__discreteCV)),

  141.         pprop_expensive     (new_uri(LV2_PORT_PROPS__expensive)),

  142.         pprop_strict_bounds (new_uri(LV2_PORT_PROPS__hasStrictBounds)),

  143.         pprop_logarithmic   (new_uri(LV2_PORT_PROPS__logarithmic)),

  144.         pprop_not_automatic (new_uri(LV2_PORT_PROPS__notAutomatic)),

  145.         pprop_not_on_gui    (new_uri(LV2_PORT_PROPS__notOnGUI)),

  146.         pprop_trigger       (new_uri(LV2_PORT_PROPS__trigger)),

  147. 

  148.         unit_unit           (new_uri(LV2_UNITS__unit)),

  149.         unit_name           (new_uri(LV2_UNITS__name)),

  150.         unit_render         (new_uri(LV2_UNITS__render)),

  151.         unit_symbol         (new_uri(LV2_UNITS__symbol)),

  152. 

  153.         unit_bar            (new_uri(LV2_UNITS__bar)),

  154.         unit_beat           (new_uri(LV2_UNITS__beat)),

  155.         unit_bpm            (new_uri(LV2_UNITS__bpm)),

  156.         unit_cent           (new_uri(LV2_UNITS__cent)),

  157.         unit_cm             (new_uri(LV2_UNITS__cm)),

  158.         unit_coef           (new_uri(LV2_UNITS__coef)),

  159.         unit_db             (new_uri(LV2_UNITS__db)),

  160.         unit_degree         (new_uri(LV2_UNITS__degree)),

  161.         unit_frame          (new_uri(LV2_UNITS__frame)),

  162.         unit_hz             (new_uri(LV2_UNITS__hz)),

  163.         unit_inch           (new_uri(LV2_UNITS__inch)),

  164.         unit_khz            (new_uri(LV2_UNITS__khz)),

  165.         unit_km             (new_uri(LV2_UNITS__km)),

  166.         unit_m              (new_uri(LV2_UNITS__m)),

  167.         unit_mhz            (new_uri(LV2_UNITS__mhz)),

  168.         unit_midi_note      (new_uri(LV2_UNITS__midiNote)),

  169.         unit_mile           (new_uri(LV2_UNITS__mile)),

  170.         unit_min            (new_uri(LV2_UNITS__min)),

  171.         unit_mm             (new_uri(LV2_UNITS__mm)),

  172.         unit_ms             (new_uri(LV2_UNITS__ms)),

  173.         unit_oct            (new_uri(LV2_UNITS__oct)),

  174.         unit_pc             (new_uri(LV2_UNITS__pc)),

  175.         unit_s              (new_uri(LV2_UNITS__s)),

  176.         unit_semitone       (new_uri(LV2_UNITS__semitone12TET)),

  177. 

  178.         ui_gtk2             (new_uri(LV2_UI__GtkUI)),

  179.         ui_qt4              (new_uri(LV2_UI__Qt4UI)),

  180.         ui_cocoa            (new_uri(LV2_UI__CocoaUI)),

  181.         ui_windows          (new_uri(LV2_UI__WindowsUI)),

  182.         ui_x11              (new_uri(LV2_UI__X11UI)),

  183.         ui_external         (new_uri(LV2_EXTERNAL_UI_URI)),

  184.         ui_external_old     (new_uri(LV2_EXTERNAL_UI_DEPRECATED_URI)),

  185. 

  186.         preset_preset       (new_uri(LV2_PRESETS__Preset)),

  187.         preset_value        (new_uri(LV2_PRESETS__value)),

  188. 

  189.         state_state         (new_uri(LV2_STATE__state)),

  190. 

  191.         value_default       (new_uri(LV2_CORE__default)),

  192.         value_minimum       (new_uri(LV2_CORE__minimum)),

  193.         value_maximum       (new_uri(LV2_CORE__maximum)),

  194. 

  195.         atom_sequence       (new_uri(LV2_ATOM__Sequence)),

  196.         atom_buffer_type    (new_uri(LV2_ATOM__bufferType)),

  197.         atom_supports       (new_uri(LV2_ATOM__supports)),

  198. 

  199.         midi_event          (new_uri(LV2_MIDI__MidiEvent)),

  200.         patch_message       (new_uri(LV2_PATCH__Message)),

  201. 

  202.         mm_default_control  (new_uri(NS_llmm "defaultMidiController")),

  203.         mm_control_type     (new_uri(NS_llmm "controllerType")),

  204.         mm_control_number   (new_uri(NS_llmm "controllerNumber")),

  205. 

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

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

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

  209.         rdfs_label          (new_uri(NS_rdfs "label"))

  210.     {}

  211. 

  212.     // Base Types

  213.     Lilv::Node port;

  214.     Lilv::Node symbol;

  215.     Lilv::Node designation;

  216.     Lilv::Node freewheeling;

  217.     Lilv::Node reportsLatency;

  218. 

  219.     // Plugin Types

  220.     Lilv::Node class_allpass;

  221.     Lilv::Node class_amplifier;

  222.     Lilv::Node class_analyzer;

  223.     Lilv::Node class_bandpass;

  224.     Lilv::Node class_chorus;

  225.     Lilv::Node class_comb;

  226.     Lilv::Node class_compressor;

  227.     Lilv::Node class_constant;

  228.     Lilv::Node class_converter;

  229.     Lilv::Node class_delay;

  230.     Lilv::Node class_distortion;

  231.     Lilv::Node class_dynamics;

  232.     Lilv::Node class_eq;

  233.     Lilv::Node class_expander;

  234.     Lilv::Node class_filter;

  235.     Lilv::Node class_flanger;

  236.     Lilv::Node class_function;

  237.     Lilv::Node class_gate;

  238.     Lilv::Node class_generator;

  239.     Lilv::Node class_highpass;

  240.     Lilv::Node class_instrument;

  241.     Lilv::Node class_limiter;

  242.     Lilv::Node class_lowpass;

  243.     Lilv::Node class_mixer;

  244.     Lilv::Node class_modulator;

  245.     Lilv::Node class_multi_eq;

  246.     Lilv::Node class_oscillator;

  247.     Lilv::Node class_para_eq;

  248.     Lilv::Node class_phaser;

  249.     Lilv::Node class_pitch;

  250.     Lilv::Node class_reverb;

  251.     Lilv::Node class_simulator;

  252.     Lilv::Node class_spatial;

  253.     Lilv::Node class_spectral;

  254.     Lilv::Node class_utility;

  255.     Lilv::Node class_waveshaper;

  256. 

  257.     // Port Types

  258.     Lilv::Node port_input;

  259.     Lilv::Node port_output;

  260.     Lilv::Node port_control;

  261.     Lilv::Node port_audio;

  262.     Lilv::Node port_cv;

  263.     Lilv::Node port_atom;

  264.     Lilv::Node port_event;

  265.     Lilv::Node port_midi_ll;

  266. 

  267.     // Port Properties

  268.     Lilv::Node pprop_optional;

  269.     Lilv::Node pprop_enumeration;

  270.     Lilv::Node pprop_integer;

  271.     Lilv::Node pprop_sample_rate;

  272.     Lilv::Node pprop_toggled;

  273.     Lilv::Node pprop_artifacts;

  274.     Lilv::Node pprop_continuous_cv;

  275.     Lilv::Node pprop_discrete_cv;

  276.     Lilv::Node pprop_expensive;

  277.     Lilv::Node pprop_strict_bounds;

  278.     Lilv::Node pprop_logarithmic;

  279.     Lilv::Node pprop_not_automatic;

  280.     Lilv::Node pprop_not_on_gui;

  281.     Lilv::Node pprop_trigger;

  282. 

  283.     // Unit Hints

  284.     Lilv::Node unit_unit;

  285.     Lilv::Node unit_name;

  286.     Lilv::Node unit_render;

  287.     Lilv::Node unit_symbol;

  288. 

  289.     // Unit Types

  290.     Lilv::Node unit_bar;

  291.     Lilv::Node unit_beat;

  292.     Lilv::Node unit_bpm;

  293.     Lilv::Node unit_cent;

  294.     Lilv::Node unit_cm;

  295.     Lilv::Node unit_coef;

  296.     Lilv::Node unit_db;

  297.     Lilv::Node unit_degree;

  298.     Lilv::Node unit_frame;

  299.     Lilv::Node unit_hz;

  300.     Lilv::Node unit_inch;

  301.     Lilv::Node unit_khz;

  302.     Lilv::Node unit_km;

  303.     Lilv::Node unit_m;

  304.     Lilv::Node unit_mhz;

  305.     Lilv::Node unit_midi_note;

  306.     Lilv::Node unit_mile;

  307.     Lilv::Node unit_min;

  308.     Lilv::Node unit_mm;

  309.     Lilv::Node unit_ms;

  310.     Lilv::Node unit_oct;

  311.     Lilv::Node unit_pc;

  312.     Lilv::Node unit_s;

  313.     Lilv::Node unit_semitone;

  314. 

  315.     // UI Types

  316.     Lilv::Node ui_gtk2;

  317.     Lilv::Node ui_qt4;

  318.     Lilv::Node ui_cocoa;

  319.     Lilv::Node ui_windows;

  320.     Lilv::Node ui_x11;

  321.     Lilv::Node ui_external;

  322.     Lilv::Node ui_external_old;

  323. 

  324.     Lilv::Node preset_preset;

  325.     Lilv::Node preset_value;

  326. 

  327.     Lilv::Node state_state;

  328. 

  329.     Lilv::Node value_default;

  330.     Lilv::Node value_minimum;

  331.     Lilv::Node value_maximum;

  332. 

  333.     Lilv::Node atom_sequence;

  334.     Lilv::Node atom_buffer_type;

  335.     Lilv::Node atom_supports;

  336. 

  337.     // Event Data/Types

  338.     Lilv::Node midi_event;

  339.     Lilv::Node patch_message;

  340. 

  341.     // MIDI CC

  342.     Lilv::Node mm_default_control;

  343.     Lilv::Node mm_control_type;

  344.     Lilv::Node mm_control_number;

  345. 

  346.     // Other

  347.     Lilv::Node dct_replaces;

  348.     Lilv::Node doap_license;

  349.     Lilv::Node rdf_type;

  350.     Lilv::Node rdfs_label;

  351. 

  352.     void init()

  353.     {

  354.         static bool needInit = true;

  355.         if (needInit)

  356.         {

  357.             needInit = false;

  358.             load_all();

  359.         }

  360.     }

  361. };

  362. 

  363. static Lv2WorldClass Lv2World;

  364. 

  365. // ------------------------------------------------------------------------------------------------

  366. 

  367. // Create new RDF object

  368. static inline

  369. const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI URI)

  370. {

  371.     const Lilv::Plugins Plugins = Lv2World.get_all_plugins();

  372. 

  373.     LILV_FOREACH(plugins, i, Plugins)

  374.     {

  375.         Lilv::Plugin Plugin(lilv_plugins_get(Plugins, i));

  376. 

  377.         if (strcmp(Plugin.get_uri().as_string(), URI) != 0)

  378.             continue;

  379. 

  380.         LV2_RDF_Descriptor* const rdf_descriptor = new LV2_RDF_Descriptor;

  381. 

  382.         // --------------------------------------------------

  383.         // Set Plugin Type

  384.         {

  385.             Lilv::Nodes types(Plugin.get_value(Lv2World.rdf_type));

  386. 

  387.             if (types.contains(Lv2World.class_allpass))

  388.                 rdf_descriptor->Type |= LV2_CLASS_ALLPASS;

  389.             if (types.contains(Lv2World.class_amplifier))

  390.                 rdf_descriptor->Type |= LV2_CLASS_AMPLIFIER;

  391.             if (types.contains(Lv2World.class_analyzer))

  392.                 rdf_descriptor->Type |= LV2_CLASS_ANALYSER;

  393.             if (types.contains(Lv2World.class_bandpass))

  394.                 rdf_descriptor->Type |= LV2_CLASS_BANDPASS;

  395.             if (types.contains(Lv2World.class_chorus))

  396.                 rdf_descriptor->Type |= LV2_CLASS_CHORUS;

  397.             if (types.contains(Lv2World.class_comb))

  398.                 rdf_descriptor->Type |= LV2_CLASS_COMB;

  399.             if (types.contains(Lv2World.class_compressor))

  400.                 rdf_descriptor->Type |= LV2_CLASS_COMPRESSOR;

  401.             if (types.contains(Lv2World.class_constant))

  402.                 rdf_descriptor->Type |= LV2_CLASS_CONSTANT;

  403.             if (types.contains(Lv2World.class_converter))

  404.                 rdf_descriptor->Type |= LV2_CLASS_CONVERTER;

  405.             if (types.contains(Lv2World.class_delay))

  406.                 rdf_descriptor->Type |= LV2_CLASS_DELAY;

  407.             if (types.contains(Lv2World.class_distortion))

  408.                 rdf_descriptor->Type |= LV2_CLASS_DISTORTION;

  409.             if (types.contains(Lv2World.class_dynamics))

  410.                 rdf_descriptor->Type |= LV2_CLASS_DYNAMICS;

  411.             if (types.contains(Lv2World.class_eq))

  412.                 rdf_descriptor->Type |= LV2_CLASS_EQ;

  413.             if (types.contains(Lv2World.class_expander))

  414.                 rdf_descriptor->Type |= LV2_CLASS_EXPANDER;

  415.             if (types.contains(Lv2World.class_filter))

  416.                 rdf_descriptor->Type |= LV2_CLASS_FILTER;

  417.             if (types.contains(Lv2World.class_flanger))

  418.                 rdf_descriptor->Type |= LV2_CLASS_FLANGER;

  419.             if (types.contains(Lv2World.class_function))

  420.                 rdf_descriptor->Type |= LV2_CLASS_FUNCTION;

  421.             if (types.contains(Lv2World.class_gate))

  422.                 rdf_descriptor->Type |= LV2_CLASS_GATE;

  423.             if (types.contains(Lv2World.class_generator))

  424.                 rdf_descriptor->Type |= LV2_CLASS_GENERATOR;

  425.             if (types.contains(Lv2World.class_highpass))

  426.                 rdf_descriptor->Type |= LV2_CLASS_HIGHPASS;

  427.             if (types.contains(Lv2World.class_instrument))

  428.                 rdf_descriptor->Type |= LV2_CLASS_INSTRUMENT;

  429.             if (types.contains(Lv2World.class_limiter))

  430.                 rdf_descriptor->Type |= LV2_CLASS_LIMITER;

  431.             if (types.contains(Lv2World.class_lowpass))

  432.                 rdf_descriptor->Type |= LV2_CLASS_LOWPASS;

  433.             if (types.contains(Lv2World.class_mixer))

  434.                 rdf_descriptor->Type |= LV2_CLASS_MIXER;

  435.             if (types.contains(Lv2World.class_modulator))

  436.                 rdf_descriptor->Type |= LV2_CLASS_MODULATOR;

  437.             if (types.contains(Lv2World.class_multi_eq))

  438.                 rdf_descriptor->Type |= LV2_CLASS_MULTI_EQ;

  439.             if (types.contains(Lv2World.class_oscillator))

  440.                 rdf_descriptor->Type |= LV2_CLASS_OSCILLATOR;

  441.             if (types.contains(Lv2World.class_para_eq))

  442.                 rdf_descriptor->Type |= LV2_CLASS_PARA_EQ;

  443.             if (types.contains(Lv2World.class_phaser))

  444.                 rdf_descriptor->Type |= LV2_CLASS_PHASER;

  445.             if (types.contains(Lv2World.class_pitch))

  446.                 rdf_descriptor->Type |= LV2_CLASS_PITCH;

  447.             if (types.contains(Lv2World.class_reverb))

  448.                 rdf_descriptor->Type |= LV2_CLASS_REVERB;

  449.             if (types.contains(Lv2World.class_simulator))

  450.                 rdf_descriptor->Type |= LV2_CLASS_SIMULATOR;

  451.             if (types.contains(Lv2World.class_spatial))

  452.                 rdf_descriptor->Type |= LV2_CLASS_SPATIAL;

  453.             if (types.contains(Lv2World.class_spectral))

  454.                 rdf_descriptor->Type |= LV2_CLASS_SPECTRAL;

  455.             if (types.contains(Lv2World.class_utility))

  456.                 rdf_descriptor->Type |= LV2_CLASS_UTILITY;

  457.             if (types.contains(Lv2World.class_waveshaper))

  458.                 rdf_descriptor->Type |= LV2_CLASS_WAVESHAPER;

  459.         }

  460. 

  461.         // --------------------------------------------------

  462.         // Set Plugin Information

  463.         {

  464.             rdf_descriptor->URI         = strdup(URI);

  465.             rdf_descriptor->Binary      = strdup(lilv_uri_to_path(Plugin.get_library_uri().as_string()));

  466.             rdf_descriptor->Bundle      = strdup(lilv_uri_to_path(Plugin.get_bundle_uri().as_string()));

  467. 

  468.             if (Plugin.get_name())

  469.                 rdf_descriptor->Name    = strdup(Plugin.get_name().as_string());

  470. 

  471.             if (Plugin.get_author_name())

  472.                 rdf_descriptor->Author  = strdup(Plugin.get_author_name().as_string());

  473. 

  474.             Lilv::Nodes license(Plugin.get_value(Lv2World.doap_license));

  475. 

  476.             if (license.size() > 0)

  477.                 rdf_descriptor->License = strdup(Lilv::Node(lilv_nodes_get(license, license.begin())).as_string());

  478.         }

  479. 

  480.         // --------------------------------------------------

  481.         // Set Plugin UniqueID

  482.         {

  483.             Lilv::Nodes replaces(Plugin.get_value(Lv2World.dct_replaces));

  484. 

  485.             if (replaces.size() > 0)

  486.             {

  487.                 Lilv::Node replaceValue(lilv_nodes_get(replaces, replaces.begin()));

  488. 

  489.                 if (replaceValue.is_uri())

  490.                 {

  491.                     const QString replaceURI(replaceValue.as_uri());

  492. 

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

  494.                     {

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

  496. 

  497.                         bool ok;

  498.                         long uniqueId = replaceId.toLong(&ok);

  499. 

  500.                         if (ok && uniqueId > 0)

  501.                             rdf_descriptor->UniqueID = uniqueId;

  502.                     }

  503.                 }

  504.             }

  505.         }

  506. 

  507.         // --------------------------------------------------

  508.         // Set Plugin Ports

  509.         {

  510.             rdf_descriptor->PortCount = Plugin.get_num_ports();

  511. 

  512.             if (rdf_descriptor->PortCount > 0)

  513.             {

  514.                 rdf_descriptor->Ports = new LV2_RDF_Port[rdf_descriptor->PortCount];

  515. 

  516.                 for (uint32_t j = 0; j < rdf_descriptor->PortCount; j++)

  517.                 {

  518.                     Lilv::Port Port(Plugin.get_port_by_index(j));

  519. 

  520.                     LV2_RDF_Port* const RDF_Port = &rdf_descriptor->Ports[j];

  521. 

  522.                     // --------------------------------------

  523.                     // Set Port Type

  524.                     {

  525.                         if (Port.is_a(Lv2World.port_input))

  526.                             RDF_Port->Type |= LV2_PORT_INPUT;

  527. 

  528.                         if (Port.is_a(Lv2World.port_output))

  529.                             RDF_Port->Type |= LV2_PORT_OUTPUT;

  530. 

  531.                         if (Port.is_a(Lv2World.port_control))

  532.                             RDF_Port->Type |= LV2_PORT_CONTROL;

  533. 

  534.                         if (Port.is_a(Lv2World.port_audio))

  535.                             RDF_Port->Type |= LV2_PORT_AUDIO;

  536. 

  537.                         if (Port.is_a(Lv2World.port_cv))

  538.                             RDF_Port->Type |= LV2_PORT_CV;

  539. 

  540.                         if (Port.is_a(Lv2World.port_atom))

  541.                         {

  542.                             RDF_Port->Type |= LV2_PORT_ATOM;

  543. 

  544.                             Lilv::Nodes bufferTypes(Port.get_value(Lv2World.atom_buffer_type));

  545.                             if (bufferTypes.contains(Lv2World.atom_sequence))

  546.                                 RDF_Port->Type |= LV2_PORT_ATOM_SEQUENCE;

  547. 

  548.                             Lilv::Nodes supports(Port.get_value(Lv2World.atom_supports));

  549.                             if (supports.contains(Lv2World.midi_event))

  550.                                 RDF_Port->Type |= LV2_PORT_SUPPORTS_MIDI_EVENT;

  551.                             if (supports.contains(Lv2World.patch_message))

  552.                                 RDF_Port->Type |= LV2_PORT_SUPPORTS_PATCH_MESSAGE;

  553.                         }

  554. 

  555.                         if (Port.is_a(Lv2World.port_event))

  556.                         {

  557.                             RDF_Port->Type |= LV2_PORT_EVENT;

  558. 

  559.                             if (Port.supports_event(Lv2World.midi_event))

  560.                                 RDF_Port->Type |= LV2_PORT_SUPPORTS_MIDI_EVENT;

  561.                         }

  562. 

  563.                         if (Port.is_a(Lv2World.port_midi_ll))

  564.                         {

  565.                             RDF_Port->Type |= LV2_PORT_MIDI_LL;

  566.                             RDF_Port->Type |= LV2_PORT_SUPPORTS_MIDI_EVENT;

  567.                         }

  568.                     }

  569. 

  570.                     // --------------------------------------

  571.                     // Set Port Properties

  572.                     {

  573.                         if (Port.has_property(Lv2World.pprop_optional))

  574.                             RDF_Port->Properties = LV2_PORT_OPTIONAL;

  575.                         if (Port.has_property(Lv2World.pprop_enumeration))

  576.                             RDF_Port->Properties = LV2_PORT_ENUMERATION;

  577.                         if (Port.has_property(Lv2World.pprop_integer))

  578.                             RDF_Port->Properties = LV2_PORT_INTEGER;

  579.                         if (Port.has_property(Lv2World.pprop_sample_rate))

  580.                             RDF_Port->Properties = LV2_PORT_SAMPLE_RATE;

  581.                         if (Port.has_property(Lv2World.pprop_toggled))

  582.                             RDF_Port->Properties = LV2_PORT_TOGGLED;

  583. 

  584.                         if (Port.has_property(Lv2World.pprop_artifacts))

  585.                             RDF_Port->Properties = LV2_PORT_CAUSES_ARTIFACTS;

  586.                         if (Port.has_property(Lv2World.pprop_continuous_cv))

  587.                             RDF_Port->Properties = LV2_PORT_CONTINUOUS_CV;

  588.                         if (Port.has_property(Lv2World.pprop_discrete_cv))

  589.                             RDF_Port->Properties = LV2_PORT_DISCRETE_CV;

  590.                         if (Port.has_property(Lv2World.pprop_expensive))

  591.                             RDF_Port->Properties = LV2_PORT_EXPENSIVE;

  592.                         if (Port.has_property(Lv2World.pprop_strict_bounds))

  593.                             RDF_Port->Properties = LV2_PORT_STRICT_BOUNDS;

  594.                         if (Port.has_property(Lv2World.pprop_logarithmic))

  595.                             RDF_Port->Properties = LV2_PORT_LOGARITHMIC;

  596.                         if (Port.has_property(Lv2World.pprop_not_automatic))

  597.                             RDF_Port->Properties = LV2_PORT_NOT_AUTOMATIC;

  598.                         if (Port.has_property(Lv2World.pprop_not_on_gui))

  599.                             RDF_Port->Properties = LV2_PORT_NOT_ON_GUI;

  600.                         if (Port.has_property(Lv2World.pprop_trigger))

  601.                             RDF_Port->Properties = LV2_PORT_TRIGGER;

  602. 

  603.                         if (Port.has_property(Lv2World.reportsLatency))

  604.                             RDF_Port->Designation = LV2_PORT_LATENCY;

  605.                     }

  606. 

  607.                     // --------------------------------------

  608.                     // Set Port Designation (FIXME)

  609.                     {

  610.                         Lilv::Nodes DesignationNodes(Port.get_value(Lv2World.designation));

  611. 

  612.                         if (DesignationNodes.size() > 0)

  613.                         {

  614.                             const char* const designation = Lilv::Node(lilv_nodes_get(DesignationNodes, DesignationNodes.begin())).as_string();

  615. 

  616.                             if (strcmp(designation, LV2_TIME__bar) == 0)

  617.                                 RDF_Port->Designation = LV2_PORT_TIME_BAR;

  618.                             else if (strcmp(designation, LV2_TIME__barBeat) == 0)

  619.                                 RDF_Port->Designation = LV2_PORT_TIME_BAR_BEAT;

  620.                             else if (strcmp(designation, LV2_TIME__beat) == 0)

  621.                                 RDF_Port->Designation = LV2_PORT_TIME_BEAT;

  622.                             else if (strcmp(designation, LV2_TIME__beatUnit) == 0)

  623.                                 RDF_Port->Designation = LV2_PORT_TIME_BEAT_UNIT;

  624.                             else if (strcmp(designation, LV2_TIME__beatsPerBar) == 0)

  625.                                 RDF_Port->Designation = LV2_PORT_TIME_BEATS_PER_BAR;

  626.                             else if (strcmp(designation, LV2_TIME__beatsPerMinute) == 0)

  627.                                 RDF_Port->Designation = LV2_PORT_TIME_BEATS_PER_MINUTE;

  628.                             else if (strcmp(designation, LV2_TIME__frame) == 0)

  629.                                 RDF_Port->Designation = LV2_PORT_TIME_FRAME;

  630.                             else if (strcmp(designation, LV2_TIME__framesPerSecond) == 0)

  631.                                 RDF_Port->Designation = LV2_PORT_TIME_FRAMES_PER_SECOND;

  632.                             else if (strcmp(designation, LV2_TIME__position) == 0)

  633.                                 RDF_Port->Designation = LV2_PORT_TIME_POSITION;

  634.                             else if (strcmp(designation, LV2_TIME__speed) == 0)

  635.                                 RDF_Port->Designation = LV2_PORT_TIME_SPEED;

  636.                             else if (strncmp(designation, LV2_PARAMETERS_PREFIX, strlen(LV2_PARAMETERS_PREFIX)) == 0)

  637.                                 pass();

  638.                             else if (strncmp(designation, LV2_PORT_GROUPS_PREFIX, strlen(LV2_PORT_GROUPS_PREFIX)) == 0)

  639.                                 pass();

  640.                             else

  641.                                 qWarning("lv2_rdf_new(%s) - got unknown Port Designation '%s'", URI, designation);

  642.                         }

  643.                     }

  644. 

  645.                     // --------------------------------------

  646.                     // Set Port Information

  647.                     {

  648.                         RDF_Port->Name   = strdup(Lilv::Node(Port.get_name()).as_string());

  649.                         RDF_Port->Symbol = strdup(Lilv::Node(Port.get_symbol()).as_string());

  650.                     }

  651. 

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

  653.                     // Set Port MIDI Map

  654.                     {

  655.                         Lilv::Nodes MidiMapNodes(Port.get_value(Lv2World.mm_default_control));

  656. 

  657.                         if (MidiMapNodes.size() > 0)

  658.                         {

  659.                             Lilv::Node MidiMapNode(lilv_nodes_get(MidiMapNodes, MidiMapNodes.begin()));

  660. 

  661.                             if (MidiMapNode.is_blank())

  662.                             {

  663.                                 Lilv::Nodes MidiMapTypeNodes(Lv2World.find_nodes(MidiMapNode, Lv2World.mm_control_type, nullptr));

  664.                                 Lilv::Nodes MidiMapNumberNodes(Lv2World.find_nodes(MidiMapNode, Lv2World.mm_control_number, nullptr));

  665. 

  666.                                 if (MidiMapTypeNodes.size() == 1 && MidiMapNumberNodes.size() == 1)

  667.                                 {

  668.                                     const char* const type = Lilv::Node(lilv_nodes_get(MidiMapTypeNodes, MidiMapTypeNodes.begin())).as_string();

  669. 

  670.                                     if (strcmp(type, LV2_MIDI_Map__CC) == 0)

  671.                                         RDF_Port->MidiMap.Type = LV2_PORT_MIDI_MAP_CC;

  672.                                     else if (strcmp(type, LV2_MIDI_Map__NRPN) == 0)

  673.                                         RDF_Port->MidiMap.Type = LV2_PORT_MIDI_MAP_NRPN;

  674.                                     else

  675.                                         qWarning("lv2_rdf_new(%s) - got unknown Port Midi Map type '%s'", URI, type);

  676. 

  677.                                     RDF_Port->MidiMap.Number = Lilv::Node(lilv_nodes_get(MidiMapNumberNodes, MidiMapNumberNodes.begin())).as_int();

  678.                                 }

  679.                             }

  680.                         }

  681.                     }

  682. 

  683.                     // --------------------------------------

  684.                     // Set Port Points

  685.                     {

  686.                         Lilv::Nodes value(Port.get_value(Lv2World.value_default));

  687. 

  688.                         if (value.size() > 0)

  689.                         {

  690.                             RDF_Port->Points.Hints  |= LV2_PORT_POINT_DEFAULT;

  691.                             RDF_Port->Points.Default = Lilv::Node(lilv_nodes_get(value, value.begin())).as_float();

  692.                         }

  693. 

  694.                         value = Port.get_value(Lv2World.value_minimum);

  695. 

  696.                         if (value.size() > 0)

  697.                         {

  698.                             RDF_Port->Points.Hints  |= LV2_PORT_POINT_MINIMUM;

  699.                             RDF_Port->Points.Minimum = Lilv::Node(lilv_nodes_get(value, value.begin())).as_float();

  700.                         }

  701. 

  702.                         value = Port.get_value(Lv2World.value_maximum);

  703. 

  704.                         if (value.size() > 0)

  705.                         {

  706.                             RDF_Port->Points.Hints  |= LV2_PORT_POINT_MAXIMUM;

  707.                             RDF_Port->Points.Maximum = Lilv::Node(lilv_nodes_get(value, value.begin())).as_float();

  708.                         }

  709.                     }

  710. 

  711.                     // --------------------------------------

  712.                     // Set Port Unit

  713.                     {

  714.                         Lilv::Nodes unit_units(Port.get_value(Lv2World.unit_unit));

  715. 

  716.                         if (unit_units.size() > 0)

  717.                         {

  718.                             RDF_Port->Unit.Hints |= LV2_PORT_UNIT;

  719. 

  720.                             if (unit_units.contains(Lv2World.unit_bar))

  721.                                 RDF_Port->Unit.Type = LV2_UNIT_BAR;

  722.                             else if (unit_units.contains(Lv2World.unit_beat))

  723.                                 RDF_Port->Unit.Type = LV2_UNIT_BEAT;

  724.                             else if (unit_units.contains(Lv2World.unit_bpm))

  725.                                 RDF_Port->Unit.Type = LV2_UNIT_BPM;

  726.                             else if (unit_units.contains(Lv2World.unit_cent))

  727.                                 RDF_Port->Unit.Type = LV2_UNIT_CENT;

  728.                             else if (unit_units.contains(Lv2World.unit_cm))

  729.                                 RDF_Port->Unit.Type = LV2_UNIT_CM;

  730.                             else if (unit_units.contains(Lv2World.unit_coef))

  731.                                 RDF_Port->Unit.Type = LV2_UNIT_COEF;

  732.                             else if (unit_units.contains(Lv2World.unit_db))

  733.                                 RDF_Port->Unit.Type = LV2_UNIT_DB;

  734.                             else if (unit_units.contains(Lv2World.unit_degree))

  735.                                 RDF_Port->Unit.Type = LV2_UNIT_DEGREE;

  736.                             else if (unit_units.contains(Lv2World.unit_frame))

  737.                                 RDF_Port->Unit.Type = LV2_UNIT_FRAME;

  738.                             else if (unit_units.contains(Lv2World.unit_hz))

  739.                                 RDF_Port->Unit.Type = LV2_UNIT_HZ;

  740.                             else if (unit_units.contains(Lv2World.unit_inch))

  741.                                 RDF_Port->Unit.Type = LV2_UNIT_INCH;

  742.                             else if (unit_units.contains(Lv2World.unit_khz))

  743.                                 RDF_Port->Unit.Type = LV2_UNIT_KHZ;

  744.                             else if (unit_units.contains(Lv2World.unit_km))

  745.                                 RDF_Port->Unit.Type = LV2_UNIT_KM;

  746.                             else if (unit_units.contains(Lv2World.unit_m))

  747.                                 RDF_Port->Unit.Type = LV2_UNIT_M;

  748.                             else if (unit_units.contains(Lv2World.unit_mhz))

  749.                                 RDF_Port->Unit.Type = LV2_UNIT_MHZ;

  750.                             else if (unit_units.contains(Lv2World.unit_midi_note))

  751.                                 RDF_Port->Unit.Type = LV2_UNIT_MIDINOTE;

  752.                             else if (unit_units.contains(Lv2World.unit_mile))

  753.                                 RDF_Port->Unit.Type = LV2_UNIT_MILE;

  754.                             else if (unit_units.contains(Lv2World.unit_min))

  755.                                 RDF_Port->Unit.Type = LV2_UNIT_MIN;

  756.                             else if (unit_units.contains(Lv2World.unit_mm))

  757.                                 RDF_Port->Unit.Type = LV2_UNIT_MM;

  758.                             else if (unit_units.contains(Lv2World.unit_ms))

  759.                                 RDF_Port->Unit.Type = LV2_UNIT_MS;

  760.                             else if (unit_units.contains(Lv2World.unit_oct))

  761.                                 RDF_Port->Unit.Type = LV2_UNIT_OCT;

  762.                             else if (unit_units.contains(Lv2World.unit_pc))

  763.                                 RDF_Port->Unit.Type = LV2_UNIT_PC;

  764.                             else if (unit_units.contains(Lv2World.unit_s))

  765.                                 RDF_Port->Unit.Type = LV2_UNIT_S;

  766.                             else if (unit_units.contains(Lv2World.unit_semitone))

  767.                                 RDF_Port->Unit.Type = LV2_UNIT_SEMITONE;

  768.                         }

  769. 

  770.                         Lilv::Nodes unit_name(Port.get_value(Lv2World.unit_name));

  771. 

  772.                         if (unit_name.size() > 0)

  773.                         {

  774.                             RDF_Port->Unit.Hints |= LV2_PORT_UNIT_NAME;

  775.                             RDF_Port->Unit.Name = strdup(Lilv::Node(lilv_nodes_get(unit_name, unit_name.begin())).as_string());

  776.                         }

  777. 

  778.                         Lilv::Nodes unit_render(Port.get_value(Lv2World.unit_render));

  779. 

  780.                         if (unit_render.size() > 0)

  781.                         {

  782.                             RDF_Port->Unit.Hints |= LV2_PORT_UNIT_RENDER;

  783.                             RDF_Port->Unit.Render = strdup(Lilv::Node(lilv_nodes_get(unit_render, unit_render.begin())).as_string());

  784.                         }

  785. 

  786.                         Lilv::Nodes unit_symbol(Port.get_value(Lv2World.unit_symbol));

  787. 

  788.                         if (unit_symbol.size() > 0)

  789.                         {

  790.                             RDF_Port->Unit.Hints |= LV2_PORT_UNIT_SYMBOL;

  791.                             RDF_Port->Unit.Symbol = strdup(Lilv::Node(lilv_nodes_get(unit_symbol, unit_symbol.begin())).as_string());

  792.                         }

  793.                     }

  794. 

  795.                     // --------------------------------------

  796.                     // Set Port Scale Points

  797. 

  798.                     Lilv::ScalePoints ScalePoints(Port.get_scale_points());

  799. 

  800.                     RDF_Port->ScalePointCount = ScalePoints.size();

  801. 

  802.                     if (RDF_Port->ScalePointCount > 0)

  803.                     {

  804.                         RDF_Port->ScalePoints = new LV2_RDF_PortScalePoint[RDF_Port->ScalePointCount];

  805. 

  806.                         uint32_t h = 0;

  807.                         LILV_FOREACH(scale_points, j, ScalePoints)

  808.                         {

  809.                             Lilv::ScalePoint ScalePoint(lilv_scale_points_get(ScalePoints, j));

  810. 

  811.                             LV2_RDF_PortScalePoint* const RDF_ScalePoint = &RDF_Port->ScalePoints[h++];

  812.                             RDF_ScalePoint->Label = strdup(Lilv::Node(ScalePoint.get_label()).as_string());

  813.                             RDF_ScalePoint->Value = Lilv::Node(ScalePoint.get_value()).as_float();

  814.                         }

  815.                     }

  816.                 }

  817.             }

  818.         }

  819. 

  820.         // --------------------------------------------------

  821.         // Set Plugin Presets (TODO)

  822.         {

  823.             Lilv::Nodes Presets(Plugin.get_related(Lv2World.preset_preset));

  824. 

  825.             rdf_descriptor->PresetCount = Presets.size();

  826. 

  827.             if (rdf_descriptor->PresetCount > 0)

  828.             {

  829.                 QStringList PresetListURIs;

  830. 

  831.                 LILV_FOREACH(nodes, j, Presets)

  832.                         // FIXME - check appliesTo()

  833.                         PresetListURIs.append(QString(Lilv::Node(lilv_nodes_get(Presets, j)).as_uri()));

  834. 

  835.                 PresetListURIs.sort();

  836. 

  837.                 rdf_descriptor->Presets = new LV2_RDF_Preset[rdf_descriptor->PresetCount];

  838. 

  839.                 LILV_FOREACH(nodes, j, Presets)

  840.                 {

  841.                     Lilv::Node PresetNode(lilv_nodes_get(Presets, j));

  842.                     Lv2World.load_resource(PresetNode);

  843. 

  844.                     LV2_URI PresetURI = PresetNode.as_uri();

  845.                     uint32_t index = PresetListURIs.indexOf(QString(PresetURI));

  846. 

  847.                     LV2_RDF_Preset* const RDF_Preset = &rdf_descriptor->Presets[index];

  848. 

  849.                     // --------------------------------------

  850.                     // Set Preset Information

  851.                     {

  852.                         RDF_Preset->URI = strdup(PresetURI);

  853. 

  854.                         Lilv::Nodes PresetLabel(Lv2World.find_nodes(PresetNode, Lv2World.rdfs_label, nullptr));

  855. 

  856.                         if (PresetLabel.size() > 0)

  857.                             RDF_Preset->Label = strdup(Lilv::Node(lilv_nodes_get(PresetLabel, PresetLabel.begin())).as_string());

  858.                     }

  859. 

  860.                     // --------------------------------------

  861.                     // Set Preset Ports

  862.                     {

  863.                         Lilv::Nodes PresetPorts(Lv2World.find_nodes(PresetNode, Lv2World.port, nullptr));

  864. 

  865.                         RDF_Preset->PortCount = PresetPorts.size();

  866. 

  867.                         if (RDF_Preset->PortCount > 0)

  868.                         {

  869.                             RDF_Preset->Ports = new LV2_RDF_PresetPort[RDF_Preset->PortCount];

  870. 

  871.                             uint32_t g = 0;

  872.                             LILV_FOREACH(nodes, k, PresetPorts)

  873.                             {

  874.                                 Lilv::Node PresetPort(lilv_nodes_get(PresetPorts, k));

  875. 

  876.                                 Lilv::Nodes PresetPortSymbol(Lv2World.find_nodes(PresetPort, Lv2World.symbol, nullptr));

  877.                                 Lilv::Nodes PresetPortValue(Lv2World.find_nodes(PresetPort, Lv2World.preset_value, nullptr));

  878. 

  879.                                 LV2_RDF_PresetPort* const RDF_PresetPort = &RDF_Preset->Ports[g++];

  880.                                 RDF_PresetPort->Symbol = strdup(Lilv::Node(lilv_nodes_get(PresetPortSymbol, PresetPortSymbol.begin())).as_string());

  881.                                 RDF_PresetPort->Value  = Lilv::Node(lilv_nodes_get(PresetPortValue, PresetPortValue.begin())).as_float();

  882.                             }

  883.                         }

  884.                     }

  885. 

  886.                     // --------------------------------------

  887.                     // Set Preset States

  888.                     {

  889.                         Lilv::Nodes PresetStates(Lv2World.find_nodes(PresetNode, Lv2World.state_state, nullptr));

  890. 

  891.                         RDF_Preset->StateCount = PresetStates.size();

  892. 

  893.                         if (RDF_Preset->StateCount > 0)

  894.                         {

  895.                             RDF_Preset->States = new LV2_RDF_PresetState[RDF_Preset->StateCount];

  896. 

  897.                             uint32_t g = 0;

  898.                             LILV_FOREACH(nodes, k, PresetStates)

  899.                             {

  900.                                 Lilv::Node PresetState(PresetStates.get(k));

  901. 

  902.                                 if (PresetState.is_blank())

  903.                                 {

  904.                                     // TODO

  905. 

  906.                                     LV2_RDF_PresetState* const RDF_PresetState = &RDF_Preset->States[g++];

  907. 

  908.                                     RDF_PresetState->Type = LV2_PRESET_STATE_NULL;

  909.                                     RDF_PresetState->Key  = nullptr;

  910.                                 }

  911.                             }

  912.                         }

  913.                     }

  914.                 }

  915.             }

  916.         }

  917. 

  918.         // --------------------------------------------------

  919.         // Set Plugin Features

  920.         {

  921.             Lilv::Nodes Features(Plugin.get_supported_features());

  922.             Lilv::Nodes FeaturesR(Plugin.get_required_features());

  923. 

  924.             rdf_descriptor->FeatureCount = Features.size();

  925. 

  926.             if (rdf_descriptor->FeatureCount > 0)

  927.             {

  928.                 rdf_descriptor->Features = new LV2_RDF_Feature[rdf_descriptor->FeatureCount];

  929. 

  930.                 uint32_t h = 0;

  931.                 LILV_FOREACH(nodes, j, Features)

  932.                 {

  933.                     Lilv::Node FeatureNode(lilv_nodes_get(Features, j));

  934. 

  935.                     LV2_RDF_Feature* const RDF_Feature = &rdf_descriptor->Features[h++];

  936.                     RDF_Feature->Type = FeaturesR.contains(FeatureNode) ? LV2_FEATURE_REQUIRED : LV2_FEATURE_OPTIONAL;

  937.                     RDF_Feature->URI  = strdup(FeatureNode.as_uri());

  938.                 }

  939.             }

  940.         }

  941. 

  942.         // --------------------------------------------------

  943.         // Set Plugin Extensions

  944.         {

  945.             Lilv::Nodes Extensions(Plugin.get_extension_data());

  946. 

  947.             rdf_descriptor->ExtensionCount = Extensions.size();

  948. 

  949.             if (rdf_descriptor->ExtensionCount > 0)

  950.             {

  951.                 rdf_descriptor->Extensions = new LV2_URI[rdf_descriptor->ExtensionCount];

  952. 

  953.                 uint32_t h = 0;

  954.                 LILV_FOREACH(nodes, j, Extensions)

  955.                 {

  956.                     Lilv::Node ExtensionNode(Lilv::Node(lilv_nodes_get(Extensions, j)));

  957. 

  958.                     rdf_descriptor->Extensions[h++] = strdup(ExtensionNode.as_uri());

  959.                 }

  960.             }

  961.         }

  962. 

  963.         // --------------------------------------------------

  964.         // Set Plugin UIs

  965.         {

  966.             Lilv::UIs UIs(Plugin.get_uis());

  967. 

  968.             rdf_descriptor->UICount = UIs.size();

  969. 

  970.             if (rdf_descriptor->UICount > 0)

  971.             {

  972.                 rdf_descriptor->UIs = new LV2_RDF_UI[rdf_descriptor->UICount];

  973. 

  974.                 uint32_t h = 0;

  975.                 LILV_FOREACH(uis, j, UIs)

  976.                 {

  977.                     Lilv::UI UI(lilv_uis_get(UIs, j));

  978. 

  979.                     LV2_RDF_UI* const RDF_UI = &rdf_descriptor->UIs[h++];

  980. 

  981.                     // --------------------------------------

  982.                     // Set UI Type

  983.                     {

  984.                         if (UI.is_a(Lv2World.ui_gtk2))

  985.                             RDF_UI->Type = LV2_UI_GTK2;

  986.                         else if (UI.is_a(Lv2World.ui_qt4))

  987.                             RDF_UI->Type = LV2_UI_QT4;

  988.                         else if (UI.is_a(Lv2World.ui_cocoa))

  989.                             RDF_UI->Type = LV2_UI_COCOA;

  990.                         else if (UI.is_a(Lv2World.ui_windows))

  991.                             RDF_UI->Type = LV2_UI_WINDOWS;

  992.                         else if (UI.is_a(Lv2World.ui_x11))

  993.                             RDF_UI->Type = LV2_UI_X11;

  994.                         else if (UI.is_a(Lv2World.ui_external))

  995.                             RDF_UI->Type = LV2_UI_EXTERNAL;

  996.                         else if (UI.is_a(Lv2World.ui_external_old))

  997.                             RDF_UI->Type = LV2_UI_OLD_EXTERNAL;

  998.                         else

  999.                             qWarning("lv2_rdf_new(%s) - got unknown UI type '%s'", URI, UI.get_uri().as_uri());

  1000.                     }

  1001. 

  1002.                     // --------------------------------------

  1003.                     // Set UI Information

  1004.                     {

  1005.                         RDF_UI->URI    = strdup(UI.get_uri().as_uri());

  1006.                         RDF_UI->Binary = strdup(lilv_uri_to_path(UI.get_binary_uri().as_string()));

  1007.                         RDF_UI->Bundle = strdup(lilv_uri_to_path(UI.get_bundle_uri().as_string()));

  1008.                     }

  1009. 

  1010.                     // --------------------------------------

  1011.                     // Set UI Features

  1012.                     {

  1013.                         Lilv::Nodes Features(UI.get_supported_features());

  1014.                         Lilv::Nodes FeaturesR(UI.get_required_features());

  1015. 

  1016.                         RDF_UI->FeatureCount = Features.size();

  1017. 

  1018.                         if (RDF_UI->FeatureCount > 0)

  1019.                         {

  1020.                             RDF_UI->Features = new LV2_RDF_Feature [RDF_UI->FeatureCount];

  1021. 

  1022.                             uint32_t h = 0;

  1023.                             LILV_FOREACH(nodes, k, Features)

  1024.                             {

  1025.                                 Lilv::Node FeatureNode(lilv_nodes_get(Features, k));

  1026. 

  1027.                                 LV2_RDF_Feature* const RDF_Feature = &RDF_UI->Features[h++];

  1028.                                 RDF_Feature->Type = FeaturesR.contains(FeatureNode) ? LV2_FEATURE_REQUIRED : LV2_FEATURE_OPTIONAL;

  1029.                                 RDF_Feature->URI  = strdup(FeatureNode.as_uri());

  1030.                             }

  1031.                         }

  1032.                     }

  1033. 

  1034.                     // --------------------------------------

  1035.                     // Set UI Extensions

  1036.                     {

  1037.                         Lilv::Nodes Extensions(UI.get_extension_data());

  1038. 

  1039.                         RDF_UI->ExtensionCount = Extensions.size();

  1040. 

  1041.                         if (RDF_UI->ExtensionCount > 0)

  1042.                         {

  1043.                             RDF_UI->Extensions = new LV2_URI[RDF_UI->ExtensionCount];

  1044. 

  1045.                             uint32_t h = 0;

  1046.                             LILV_FOREACH(nodes, k, Extensions)

  1047.                             {

  1048.                                 Lilv::Node ExtensionNode(lilv_nodes_get(Extensions, k));

  1049. 

  1050.                                 RDF_UI->Extensions[h++] = strdup(ExtensionNode.as_uri());

  1051.                             }

  1052.                         }

  1053.                     }

  1054.                 }

  1055.             }

  1056.         }

  1057. 

  1058.         return rdf_descriptor;

  1059.     }

  1060. 

  1061.     return nullptr;

  1062. }

  1063. 

  1064. // Copy RDF object

  1065. static inline

  1066. const LV2_RDF_Descriptor* lv2_rdf_dup(const LV2_RDF_Descriptor* const rdf_descriptor)

  1067. {

  1068.     LV2_RDF_Descriptor* const new_descriptor = new LV2_RDF_Descriptor;

  1069. 

  1070.     new_descriptor->Type           = rdf_descriptor->Type;

  1071.     new_descriptor->UniqueID       = rdf_descriptor->UniqueID;

  1072. 

  1073.     new_descriptor->PortCount      = rdf_descriptor->PortCount;

  1074.     new_descriptor->PresetCount    = rdf_descriptor->PresetCount;

  1075.     new_descriptor->FeatureCount   = rdf_descriptor->FeatureCount;

  1076.     new_descriptor->ExtensionCount = rdf_descriptor->ExtensionCount;

  1077.     new_descriptor->UICount        = rdf_descriptor->UICount;

  1078. 

  1079.     if (rdf_descriptor->URI)

  1080.         new_descriptor->URI        = strdup(rdf_descriptor->URI);

  1081. 

  1082.     if (rdf_descriptor->Name)

  1083.         new_descriptor->Name       = strdup(rdf_descriptor->Name);

  1084. 

  1085.     if (rdf_descriptor->Author)

  1086.         new_descriptor->Author     = strdup(rdf_descriptor->Author);

  1087. 

  1088.     if (rdf_descriptor->License)

  1089.         new_descriptor->License    = strdup(rdf_descriptor->License);

  1090. 

  1091.     if (rdf_descriptor->Binary)

  1092.         new_descriptor->Binary     = strdup(rdf_descriptor->Binary);

  1093. 

  1094.     if (rdf_descriptor->Bundle)

  1095.         new_descriptor->Bundle     = strdup(rdf_descriptor->Bundle);

  1096. 

  1097.     // Ports

  1098.     if (new_descriptor->PortCount > 0)

  1099.     {

  1100.         new_descriptor->Ports = new LV2_RDF_Port[new_descriptor->PortCount];

  1101. 

  1102.         for (uint32_t i=0; i < new_descriptor->PortCount; i++)

  1103.         {

  1104.             LV2_RDF_Port* const Port = &new_descriptor->Ports[i];

  1105. 

  1106.             Port->Type            = rdf_descriptor->Ports[i].Type;

  1107.             Port->Properties      = rdf_descriptor->Ports[i].Properties;

  1108.             Port->Designation     = rdf_descriptor->Ports[i].Designation;

  1109. 

  1110.             Port->MidiMap.Type    = rdf_descriptor->Ports[i].MidiMap.Type;

  1111.             Port->MidiMap.Number  = rdf_descriptor->Ports[i].MidiMap.Number;

  1112. 

  1113.             Port->Points.Hints    = rdf_descriptor->Ports[i].Points.Hints;

  1114.             Port->Points.Default  = rdf_descriptor->Ports[i].Points.Default;

  1115.             Port->Points.Minimum  = rdf_descriptor->Ports[i].Points.Minimum;

  1116.             Port->Points.Maximum  = rdf_descriptor->Ports[i].Points.Maximum;

  1117. 

  1118.             Port->Unit.Type       = rdf_descriptor->Ports[i].Unit.Type;

  1119.             Port->Unit.Hints      = rdf_descriptor->Ports[i].Unit.Hints;

  1120. 

  1121.             Port->ScalePointCount = rdf_descriptor->Ports[i].ScalePointCount;

  1122. 

  1123.             if (rdf_descriptor->Ports[i].Name)

  1124.                 Port->Name        = strdup(rdf_descriptor->Ports[i].Name);

  1125. 

  1126.             if (rdf_descriptor->Ports[i].Symbol)

  1127.                 Port->Symbol      = strdup(rdf_descriptor->Ports[i].Symbol);

  1128. 

  1129.             if (rdf_descriptor->Ports[i].Unit.Name)

  1130.                 Port->Unit.Name   = strdup(rdf_descriptor->Ports[i].Unit.Name);

  1131. 

  1132.             if (rdf_descriptor->Ports[i].Unit.Render)

  1133.                 Port->Unit.Render = strdup(rdf_descriptor->Ports[i].Unit.Render);

  1134. 

  1135.             if (rdf_descriptor->Ports[i].Unit.Symbol)

  1136.                 Port->Unit.Symbol = strdup(rdf_descriptor->Ports[i].Unit.Symbol);

  1137. 

  1138.             if (Port->ScalePointCount > 0)

  1139.             {

  1140.                 Port->ScalePoints = new LV2_RDF_PortScalePoint[Port->ScalePointCount];

  1141. 

  1142.                 for (uint32_t j=0; j < Port->ScalePointCount; j++)

  1143.                 {

  1144.                     Port->ScalePoints[j].Value = rdf_descriptor->Ports[i].ScalePoints[j].Value;

  1145. 

  1146.                     if (rdf_descriptor->Ports[i].ScalePoints[j].Label)

  1147.                         Port->ScalePoints[j].Label = strdup(rdf_descriptor->Ports[i].ScalePoints[j].Label);

  1148.                 }

  1149.             }

  1150.         }

  1151.     }

  1152. 

  1153.     // Presets

  1154.     if (new_descriptor->PresetCount > 0)

  1155.     {

  1156.         new_descriptor->Presets = new LV2_RDF_Preset[new_descriptor->PresetCount];

  1157. 

  1158.         for (uint32_t i=0; i < new_descriptor->PresetCount; i++)

  1159.         {

  1160.             LV2_RDF_Preset* const Preset = &new_descriptor->Presets[i];

  1161. 

  1162.             Preset->PortCount  = rdf_descriptor->Presets[i].PortCount;

  1163.             Preset->StateCount = rdf_descriptor->Presets[i].StateCount;

  1164. 

  1165.             if (rdf_descriptor->Presets[i].URI)

  1166.                 Preset->URI    = strdup(rdf_descriptor->Presets[i].URI);

  1167. 

  1168.             if (rdf_descriptor->Presets[i].Label)

  1169.                 Preset->Label  = strdup(rdf_descriptor->Presets[i].Label);

  1170. 

  1171.             // Ports

  1172.             if (Preset->PortCount > 0)

  1173.             {

  1174.                 Preset->Ports = new LV2_RDF_PresetPort[Preset->PortCount];

  1175. 

  1176.                 for (uint32_t j=0; j < Preset->PortCount; j++)

  1177.                 {

  1178.                     Preset->Ports[j].Value = rdf_descriptor->Presets[i].Ports[j].Value;

  1179. 

  1180.                     if (rdf_descriptor->Presets[i].Ports[j].Symbol)

  1181.                         Preset->Ports[j].Symbol = strdup(rdf_descriptor->Presets[i].Ports[j].Symbol);

  1182.                 }

  1183.             }

  1184. 

  1185.             // States

  1186.             if (Preset->StateCount > 0)

  1187.             {

  1188.                 Preset->States = new LV2_RDF_PresetState[Preset->StateCount];

  1189. 

  1190.                 for (uint32_t j=0; j < Preset->StateCount; j++)

  1191.                 {

  1192.                     Preset->States[j].Type = rdf_descriptor->Presets[i].States[j].Type;

  1193. 

  1194.                     if (rdf_descriptor->Presets[i].States[j].Key)

  1195.                         Preset->States[j].Key = strdup(rdf_descriptor->Presets[i].States[j].Key);

  1196. 

  1197.                     // TODO - copy value

  1198.                 }

  1199.             }

  1200.         }

  1201.     }

  1202. 

  1203.     // Features

  1204.     if (new_descriptor->FeatureCount > 0)

  1205.     {

  1206.         new_descriptor->Features = new LV2_RDF_Feature[new_descriptor->FeatureCount];

  1207. 

  1208.         for (uint32_t i=0; i < new_descriptor->FeatureCount; i++)

  1209.         {

  1210.             new_descriptor->Features[i].Type = rdf_descriptor->Features[i].Type;

  1211. 

  1212.             if (rdf_descriptor->Features[i].URI)

  1213.                 new_descriptor->Features[i].URI = strdup(rdf_descriptor->Features[i].URI);

  1214.         }

  1215.     }

  1216. 

  1217.     // Extensions

  1218.     if (new_descriptor->ExtensionCount > 0)

  1219.     {

  1220.         new_descriptor->Extensions = new LV2_URI[new_descriptor->ExtensionCount];

  1221. 

  1222.         for (uint32_t i=0; i < new_descriptor->ExtensionCount; i++)

  1223.         {

  1224.             if (rdf_descriptor->Extensions[i])

  1225.                 new_descriptor->Extensions[i] = strdup(rdf_descriptor->Extensions[i]);

  1226.         }

  1227.     }

  1228. 

  1229.     // UIs

  1230.     if (new_descriptor->UICount > 0)

  1231.     {

  1232.         new_descriptor->UIs = new LV2_RDF_UI[new_descriptor->UICount];

  1233. 

  1234.         for (uint32_t i=0; i < new_descriptor->UICount; i++)

  1235.         {

  1236.             LV2_RDF_UI* const UI = &new_descriptor->UIs[i];

  1237. 

  1238.             UI->Type           = rdf_descriptor->UIs[i].Type;

  1239. 

  1240.             UI->FeatureCount   = rdf_descriptor->UIs[i].FeatureCount;

  1241.             UI->ExtensionCount = rdf_descriptor->UIs[i].ExtensionCount;

  1242. 

  1243.             if (rdf_descriptor->UIs[i].URI)

  1244.                 UI->URI        = strdup(rdf_descriptor->UIs[i].URI);

  1245. 

  1246.             if (rdf_descriptor->UIs[i].Binary)

  1247.                 UI->Binary     = strdup(rdf_descriptor->UIs[i].Binary);

  1248. 

  1249.             if (rdf_descriptor->UIs[i].Bundle)

  1250.                 UI->Bundle     = strdup(rdf_descriptor->UIs[i].Bundle);

  1251. 

  1252.             // UI Features

  1253.             if (UI->FeatureCount > 0)

  1254.             {

  1255.                 UI->Features = new LV2_RDF_Feature[UI->FeatureCount];

  1256. 

  1257.                 for (uint32_t j=0; j < UI->FeatureCount; j++)

  1258.                 {

  1259.                     UI->Features[j].Type = rdf_descriptor->UIs[i].Features[j].Type;

  1260. 

  1261.                     if (rdf_descriptor->UIs[i].Features[j].URI)

  1262.                         UI->Features[j].URI = strdup(rdf_descriptor->UIs[i].Features[j].URI);

  1263.                 }

  1264.             }

  1265. 

  1266.             // UI Extensions

  1267.             if (UI->ExtensionCount > 0)

  1268.             {

  1269.                 UI->Extensions = new LV2_URI[UI->ExtensionCount];

  1270. 

  1271.                 for (uint32_t j=0; j < UI->ExtensionCount; j++)

  1272.                 {

  1273.                     if (rdf_descriptor->UIs[i].Extensions[j])

  1274.                         UI->Extensions[j] = strdup(rdf_descriptor->UIs[i].Extensions[j]);

  1275.                 }

  1276.             }

  1277.         }

  1278.     }

  1279. 

  1280.     return new_descriptor;

  1281. }

  1282. 

  1283. // Delete object

  1284. static inline

  1285. void lv2_rdf_free(const LV2_RDF_Descriptor* const rdf_descriptor)

  1286. {

  1287.     if (rdf_descriptor->URI)

  1288.         free((void*)rdf_descriptor->URI);

  1289. 

  1290.     if (rdf_descriptor->Name)

  1291.         free((void*)rdf_descriptor->Name);

  1292. 

  1293.     if (rdf_descriptor->Author)

  1294.         free((void*)rdf_descriptor->Author);

  1295. 

  1296.     if (rdf_descriptor->License)

  1297.         free((void*)rdf_descriptor->License);

  1298. 

  1299.     if (rdf_descriptor->Binary)

  1300.         free((void*)rdf_descriptor->Binary);

  1301. 

  1302.     if (rdf_descriptor->Bundle)

  1303.         free((void*)rdf_descriptor->Bundle);

  1304. 

  1305.     if (rdf_descriptor->PortCount > 0)

  1306.     {

  1307.         for (uint32_t i=0; i < rdf_descriptor->PortCount; i++)

  1308.         {

  1309.             const LV2_RDF_Port* const Port = &rdf_descriptor->Ports[i];

  1310. 

  1311.             if (Port->Name)

  1312.                 free((void*)Port->Name);

  1313. 

  1314.             if (Port->Symbol)

  1315.                 free((void*)Port->Symbol);

  1316. 

  1317.             if (Port->Unit.Name)

  1318.                 free((void*)Port->Unit.Name);

  1319. 

  1320.             if (Port->Unit.Render)

  1321.                 free((void*)Port->Unit.Render);

  1322. 

  1323.             if (Port->Unit.Symbol)

  1324.                 free((void*)Port->Unit.Symbol);

  1325. 

  1326.             if (Port->ScalePointCount > 0)

  1327.             {

  1328.                 for (uint32_t j=0; j < Port->ScalePointCount; j++)

  1329.                 {

  1330.                     const LV2_RDF_PortScalePoint* const PortScalePoint = &Port->ScalePoints[j];

  1331. 

  1332.                     if (PortScalePoint->Label)

  1333.                         free((void*)PortScalePoint->Label);

  1334.                 }

  1335.                 delete[] Port->ScalePoints;

  1336.             }

  1337.         }

  1338.         delete[] rdf_descriptor->Ports;

  1339.     }

  1340. 

  1341.     if (rdf_descriptor->PresetCount > 0)

  1342.     {

  1343.         for (uint32_t i=0; i < rdf_descriptor->PresetCount; i++)

  1344.         {

  1345.             const LV2_RDF_Preset* const Preset = &rdf_descriptor->Presets[i];

  1346. 

  1347.             if (Preset->URI)

  1348.                 free((void*)Preset->URI);

  1349. 

  1350.             if (Preset->Label)

  1351.                 free((void*)Preset->Label);

  1352. 

  1353.             if (Preset->PortCount > 0)

  1354.             {

  1355.                 for (uint32_t j=0; j < Preset->PortCount; j++)

  1356.                 {

  1357.                     const LV2_RDF_PresetPort* const PresetPort = &Preset->Ports[j];

  1358. 

  1359.                     if (PresetPort->Symbol)

  1360.                         free((void*)PresetPort->Symbol);

  1361.                 }

  1362.                 delete[] Preset->Ports;

  1363.             }

  1364. 

  1365.             if (Preset->StateCount > 0)

  1366.             {

  1367.                 for (uint32_t j=0; j < Preset->StateCount; j++)

  1368.                 {

  1369.                     const LV2_RDF_PresetState* const PresetState = &Preset->States[j];

  1370. 

  1371.                     if (PresetState->Key)

  1372.                         free((void*)PresetState->Key);

  1373. 

  1374.                     // TODO - delete value

  1375.                 }

  1376.                 delete[] Preset->States;

  1377.             }

  1378.         }

  1379.         delete[] rdf_descriptor->Presets;

  1380.     }

  1381. 

  1382.     if (rdf_descriptor->FeatureCount > 0)

  1383.     {

  1384.         for (uint32_t i=0; i < rdf_descriptor->FeatureCount; i++)

  1385.         {

  1386.             const LV2_RDF_Feature* const Feature = &rdf_descriptor->Features[i];

  1387. 

  1388.             if (Feature->URI)

  1389.                 free((void*)Feature->URI);

  1390.         }

  1391.         delete[] rdf_descriptor->Features;

  1392.     }

  1393. 

  1394.     if (rdf_descriptor->ExtensionCount > 0)

  1395.     {

  1396.         for (uint32_t i=0; i < rdf_descriptor->ExtensionCount; i++)

  1397.         {

  1398.             const LV2_URI Extension = rdf_descriptor->Extensions[i];

  1399. 

  1400.             if (Extension)

  1401.                 free((void*)Extension);

  1402.         }

  1403.         delete[] rdf_descriptor->Extensions;

  1404.     }

  1405. 

  1406.     if (rdf_descriptor->UICount > 0)

  1407.     {

  1408.         for (uint32_t i=0; i < rdf_descriptor->UICount; i++)

  1409.         {

  1410.             const LV2_RDF_UI* const UI = &rdf_descriptor->UIs[i];

  1411. 

  1412.             if (UI->URI)

  1413.                 free((void*)UI->URI);

  1414. 

  1415.             if (UI->Binary)

  1416.                 free((void*)UI->Binary);

  1417. 

  1418.             if (UI->Bundle)

  1419.                 free((void*)UI->Bundle);

  1420. 

  1421.             if (UI->FeatureCount > 0)

  1422.             {

  1423.                 for (uint32_t j=0; j < UI->FeatureCount; j++)

  1424.                 {

  1425.                     const LV2_RDF_Feature* const Feature = &UI->Features[j];

  1426. 

  1427.                     if (Feature->URI)

  1428.                         free((void*)Feature->URI);

  1429.                 }

  1430.                 delete[] UI->Features;

  1431.             }

  1432. 

  1433.             if (UI->ExtensionCount > 0)

  1434.             {

  1435.                 for (uint32_t j=0; j < UI->ExtensionCount; j++)

  1436.                 {

  1437.                     const LV2_URI Extension = UI->Extensions[j];

  1438. 

  1439.                     if (Extension)

  1440.                         free((void*)Extension);

  1441.                 }

  1442.                 delete[] UI->Extensions;

  1443.             }

  1444.         }

  1445.         delete[] rdf_descriptor->UIs;

  1446.     }

  1447. 

  1448.     delete rdf_descriptor;

  1449. }

  1450. 

  1451. // ------------------------------------------------------------------------------------------------

  1452. 

  1453. static inline

  1454. bool is_lv2_feature_supported(const LV2_URI uri)

  1455. {

  1456.     if (strcmp(uri, LV2_CORE__hardRTCapable) == 0)

  1457.         return true;

  1458.     if (strcmp(uri, LV2_CORE__inPlaceBroken) == 0)

  1459.         return true;

  1460.     if (strcmp(uri, LV2_CORE__isLive) == 0)

  1461.         return true;

  1462.     if (strcmp(uri, LV2_EVENT_URI) == 0)

  1463.         return true;

  1464.     if (strcmp(uri, LV2_LOG__log) == 0)

  1465.         return true;

  1466.     if (strcmp(uri, LV2_PROGRAMS__Host) == 0)

  1467.         return true;

  1468.     if (strcmp(uri, LV2_RTSAFE_MEMORY_POOL_URI) == 0)

  1469.         return true;

  1470.     if (strcmp(uri, LV2_STATE__makePath) == 0)

  1471.         return true;

  1472.     if (strcmp(uri, LV2_STATE__mapPath) == 0)

  1473.         return true;

  1474.     if (strcmp(uri, LV2_PORT_PROPS__supportsStrictBounds) == 0)

  1475.         return true;

  1476.     if (strcmp(uri, LV2_URI_MAP_URI) == 0)

  1477.         return true;

  1478.     if (strcmp(uri, LV2_URID__map) == 0)

  1479.         return true;

  1480.     if (strcmp(uri, LV2_URID__unmap) == 0)

  1481.         return true;

  1482.     if (strcmp(uri, LV2_WORKER__schedule) == 0)

  1483.         return true;

  1484.     return false;

  1485. }

  1486. 

  1487. static inline

  1488. bool is_lv2_ui_feature_supported(const LV2_URI uri)

  1489. {

  1490.     if (is_lv2_feature_supported(uri))

  1491.         return true;

  1492.     if (strcmp(uri, LV2_DATA_ACCESS_URI) == 0)

  1493.         return true;

  1494.     if (strcmp(uri, LV2_INSTANCE_ACCESS_URI) == 0)

  1495.         return true;

  1496.     if (strcmp(uri, LV2_UI__noUserResize) == 0)

  1497.         return true;

  1498.     if (strcmp(uri, LV2_UI__fixedSize) == 0)

  1499.         return true;

  1500.     if (strcmp(uri, LV2_UI__parent) == 0)

  1501.         return true;

  1502.     if (strcmp(uri, LV2_UI__portMap) == 0)

  1503.         return true;

  1504.     if (strcmp(uri, LV2_UI__portSubscribe) == 0)

  1505.         return false; // TODO: uninplemented

  1506.     if (strcmp(uri, LV2_UI__resize) == 0)

  1507.         return true;

  1508.     if (strcmp(uri, LV2_UI__touch) == 0)

  1509.         return false; // TODO: uninplemented

  1510.     if (strcmp(uri, LV2_UI_PREFIX "makeResident") == 0)

  1511.         return true;

  1512.     if (strcmp(uri, LV2_EXTERNAL_UI_URI) == 0)

  1513.         return true;

  1514.     if (strcmp(uri, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)

  1515.         return true;

  1516.     return false;

  1517. }

  1518. 

  1519. static inline

  1520. LV2_URI lv2_get_ui_uri(const int UiType)

  1521. {

  1522.     switch (UiType)

  1523.     {

  1524.     case LV2_UI_GTK2:

  1525.         return LV2_UI__GtkUI;

  1526.     case LV2_UI_QT4:

  1527.         return LV2_UI__Qt4UI;

  1528.     case LV2_UI_COCOA:

  1529.         return LV2_UI__CocoaUI;

  1530.     case LV2_UI_WINDOWS:

  1531.         return LV2_UI__WindowsUI;

  1532.     case LV2_UI_X11:

  1533.         return LV2_UI__X11UI;

  1534.     case LV2_UI_EXTERNAL:

  1535.         return LV2_EXTERNAL_UI_URI;

  1536.     case LV2_UI_OLD_EXTERNAL:

  1537.         return LV2_EXTERNAL_UI_DEPRECATED_URI;

  1538.     default:

  1539.         return "UI URI Type Not Supported";

  1540.     }

  1541. }

  1542. 

  1543. #endif // CARLA_LV2_INCLUDES_H