?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
VST3: fetch midi mappings all at once, use it for note/sound-off
[carla.git] / source / utils / CarlaLv2Utils.hpp
blob7843cb97229a05704d9e3f0f2383a6832c2ffaea
1 /*
2 * Carla LV2 utils
3 * Copyright (C) 2011-2023 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 #include "CarlaStringList.hpp"
23 #include "CarlaMIDI.h"
24
25 #ifndef nullptr
26 # undef NULL
27 # define NULL nullptr
28 #endif
29
30 // disable -Wdocumentation for LV2 headers
31 #if defined(__clang__) && (__clang_major__ * 100 + __clang_minor__) > 300
32 # pragma clang diagnostic push
33 # pragma clang diagnostic ignored "-Wdocumentation"
34 #endif
35
36 #include "lv2/lv2.h"
37 #include "lv2/atom.h"
38 #include "lv2/atom-forge.h"
39 #include "lv2/atom-helpers.h"
40 #include "lv2/atom-util.h"
41 #include "lv2/buf-size.h"
42 #include "lv2/data-access.h"
43 // dynmanifest
44 #include "lv2/event.h"
45 #include "lv2/event-helpers.h"
46 #include "lv2/inline-display.h"
47 #include "lv2/instance-access.h"
48 #include "lv2/log.h"
49 // logger
50 #include "lv2/midi.h"
51 #include "lv2/midnam.h"
52 // morph
53 #include "lv2/options.h"
54 #include "lv2/parameters.h"
55 #include "lv2/patch.h"
56 #include "lv2/port-groups.h"
57 #include "lv2/port-props.h"
58 #include "lv2/presets.h"
59 #include "lv2/resize-port.h"
60 #include "lv2/state.h"
61 #include "lv2/time.h"
62 #include "lv2/ui.h"
63 #include "lv2/units.h"
64 #include "lv2/uri-map.h"
65 #include "lv2/urid.h"
66 #include "lv2/worker.h"
67
68 #include "lv2/lv2-miditype.h"
69 #include "lv2/lv2-midifunctions.h"
70 #include "lv2/lv2_external_ui.h"
71 #include "lv2/lv2_kxstudio_properties.h"
72 #include "lv2/lv2_programs.h"
73 #include "lv2/lv2_rtmempool.h"
74
75 #include "lv2/control-input-port-change-request.h"
76
77 #include "lilv/lilvmm.hpp"
78 #include "sratom/sratom.h"
79 #include "lilv/config/lilv_config.h"
80
81 // enable -Wdocumentation again
82 #if defined(__clang__) && (__clang_major__ * 100 + __clang_minor__) > 300
83 # pragma clang diagnostic pop
84 #endif
85
86 #include "lv2_rdf.hpp"
87
88 #if defined(CARLA_UTILS_USE_QT)
89 # include <QtCore/QStringList>
90 #else
91 # include "water/text/StringArray.h"
92 #endif
93
94 // used for scalepoint sorting
95 #include <map>
96 typedef std::map<double,const LilvScalePoint*> LilvScalePointMap;
97
98 // --------------------------------------------------------------------------------------------------------------------
99 // Define namespaces and missing prefixes
100
101 #define NS_dct "http://purl.org/dc/terms/"
102 #define NS_doap "http://usefulinc.com/ns/doap#"
103 #define NS_rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
104 #define NS_rdfs "http://www.w3.org/2000/01/rdf-schema#"
105 #define NS_llmm "http://ll-plugins.nongnu.org/lv2/ext/midimap#"
106 #define NS_devp "http://lv2plug.in/ns/dev/extportinfo#"
107 #define NS_mod "http://moddevices.com/ns/modgui#"
108
109 #define LV2_MIDI_Map__CC "http://ll-plugins.nongnu.org/lv2/namespace#CC"
110 #define LV2_MIDI_Map__NRPN "http://ll-plugins.nongnu.org/lv2/namespace#NRPN"
111
112 #define LV2_MIDI_LL__MidiPort "http://ll-plugins.nongnu.org/lv2/ext/MidiPort"
113
114 #define LV2_UI__makeResident LV2_UI_PREFIX "makeResident"
115 #define LV2_UI__makeSONameResident LV2_UI_PREFIX "makeSONameResident"
116
117 // TODO: update LV2 headers once again
118 #define LV2_CORE__Parameter LV2_CORE_PREFIX "Parameter" ///< http://lv2plug.in/ns/lv2core#Parameter
119 #define LV2_CORE__enabled LV2_CORE_PREFIX "enabled" ///< http://lv2plug.in/ns/lv2core#enabled
120 #define LV2_CORE__isSideChain LV2_CORE_PREFIX "isSideChain" ///< http://lv2plug.in/ns/lv2core#isSideChain
121
122 // --------------------------------------------------------------------------------------------------------------------
123 // Custom Atom types
124
125 struct LV2_Atom_MidiEvent {
126 LV2_Atom atom; /**< Atom header. */
127 uint8_t data[4]; /**< MIDI data (body). */
128 };
129
130 static inline
131 uint32_t lv2_atom_total_size(const LV2_Atom_MidiEvent& midiEv)
132 {
133 return static_cast<uint32_t>(sizeof(LV2_Atom)) + midiEv.atom.size;
134 }
135
136 // ---------------------------------------------------------------------------------------------------------------------
137 // -Weffc++ compat ext widget
138
139 extern "C" {
140
141 typedef struct _LV2_External_UI_Widget_Compat {
142 void (*run )(struct _LV2_External_UI_Widget_Compat*);
143 void (*show)(struct _LV2_External_UI_Widget_Compat*);
144 void (*hide)(struct _LV2_External_UI_Widget_Compat*);
145
146 _LV2_External_UI_Widget_Compat() noexcept
147 : run(nullptr), show(nullptr), hide(nullptr) {}
148
149 } LV2_External_UI_Widget_Compat;
150
151 }
152
153 // --------------------------------------------------------------------------------------------------------------------
154 // Our LV2 World class
155
156 class Lv2WorldClass : public Lilv::World
157 {
158 public:
159 // Base Types
160 Lilv::Node port;
161 Lilv::Node symbol;
162 Lilv::Node designation;
163 Lilv::Node freeWheeling;
164 Lilv::Node reportsLatency;
165
166 // Plugin Types
167 Lilv::Node class_allpass;
168 Lilv::Node class_amplifier;
169 Lilv::Node class_analyzer;
170 Lilv::Node class_bandpass;
171 Lilv::Node class_chorus;
172 Lilv::Node class_comb;
173 Lilv::Node class_compressor;
174 Lilv::Node class_constant;
175 Lilv::Node class_converter;
176 Lilv::Node class_delay;
177 Lilv::Node class_distortion;
178 Lilv::Node class_dynamics;
179 Lilv::Node class_eq;
180 Lilv::Node class_envelope;
181 Lilv::Node class_expander;
182 Lilv::Node class_filter;
183 Lilv::Node class_flanger;
184 Lilv::Node class_function;
185 Lilv::Node class_gate;
186 Lilv::Node class_generator;
187 Lilv::Node class_highpass;
188 Lilv::Node class_instrument;
189 Lilv::Node class_limiter;
190 Lilv::Node class_lowpass;
191 Lilv::Node class_mixer;
192 Lilv::Node class_modulator;
193 Lilv::Node class_multiEQ;
194 Lilv::Node class_oscillator;
195 Lilv::Node class_paraEQ;
196 Lilv::Node class_phaser;
197 Lilv::Node class_pitch;
198 Lilv::Node class_reverb;
199 Lilv::Node class_simulator;
200 Lilv::Node class_spatial;
201 Lilv::Node class_spectral;
202 Lilv::Node class_utility;
203 Lilv::Node class_waveshaper;
204
205 // Port Types
206 Lilv::Node port_input;
207 Lilv::Node port_output;
208 Lilv::Node port_control;
209 Lilv::Node port_audio;
210 Lilv::Node port_cv;
211 Lilv::Node port_atom;
212 Lilv::Node port_event;
213 Lilv::Node port_midi;
214
215 // Port Properties
216 Lilv::Node pprop_optional;
217 Lilv::Node pprop_enumeration;
218 Lilv::Node pprop_integer;
219 Lilv::Node pprop_isSideChain;
220 Lilv::Node pprop_sampleRate;
221 Lilv::Node pprop_toggled;
222 Lilv::Node pprop_artifacts;
223 Lilv::Node pprop_continuousCV;
224 Lilv::Node pprop_discreteCV;
225 Lilv::Node pprop_expensive;
226 Lilv::Node pprop_strictBounds;
227 Lilv::Node pprop_logarithmic;
228 Lilv::Node pprop_notAutomatic;
229 Lilv::Node pprop_notOnGUI;
230 Lilv::Node pprop_trigger;
231 Lilv::Node pprop_nonAutomatable;
232
233 // Unit Hints
234 Lilv::Node unit_name;
235 Lilv::Node unit_render;
236 Lilv::Node unit_symbol;
237 Lilv::Node unit_unit;
238
239 // UI Types
240 Lilv::Node ui;
241 Lilv::Node ui_gtk2;
242 Lilv::Node ui_gtk3;
243 Lilv::Node ui_qt4;
244 Lilv::Node ui_qt5;
245 Lilv::Node ui_cocoa;
246 Lilv::Node ui_windows;
247 Lilv::Node ui_x11;
248 Lilv::Node ui_external;
249 Lilv::Node ui_externalOld;
250
251 // Misc
252 Lilv::Node atom_bufferType;
253 Lilv::Node atom_sequence;
254 Lilv::Node atom_supports;
255
256 Lilv::Node lv2_name;
257 Lilv::Node lv2_symbol;
258 Lilv::Node patch_readable;
259 Lilv::Node patch_writable;
260 Lilv::Node pg_group;
261 Lilv::Node pg_sideChainOf;
262 Lilv::Node preset_preset;
263 Lilv::Node state_state;
264
265 Lilv::Node ui_portIndex;
266 Lilv::Node ui_portNotif;
267 Lilv::Node ui_protocol;
268
269 Lilv::Node value_default;
270 Lilv::Node value_minimum;
271 Lilv::Node value_maximum;
272
273 Lilv::Node rz_asLargeAs;
274 Lilv::Node rz_minSize;
275
276 // Port Data Types
277 Lilv::Node midi_binding;
278 Lilv::Node midi_ctlrNumber;
279 Lilv::Node midi_event;
280 Lilv::Node patch_message;
281 Lilv::Node time_position;
282
283 // MIDI CC
284 Lilv::Node mm_defaultControl;
285 Lilv::Node mm_controlType;
286 Lilv::Node mm_controlNumber;
287
288 // Other
289 Lilv::Node dct_replaces;
290 Lilv::Node doap_license;
291 Lilv::Node rdf_type;
292 Lilv::Node rdfs_comment;
293 Lilv::Node rdfs_label;
294 Lilv::Node rdfs_range;
295
296 bool needsInit;
297
298 const LilvPlugins* allPlugins;
299 const LilvPlugin** cachedPlugins;
300 uint pluginCount;
301
302 // ----------------------------------------------------------------------------------------------------------------
303
304 Lv2WorldClass()
305 : Lilv::World(),
306 port (new_uri(LV2_CORE__port)),
307 symbol (new_uri(LV2_CORE__symbol)),
308 designation (new_uri(LV2_CORE__designation)),
309 freeWheeling (new_uri(LV2_CORE__freeWheeling)),
310 reportsLatency (new_uri(LV2_CORE__reportsLatency)),
311
312 class_allpass (new_uri(LV2_CORE__AllpassPlugin)),
313 class_amplifier (new_uri(LV2_CORE__AmplifierPlugin)),
314 class_analyzer (new_uri(LV2_CORE__AnalyserPlugin)),
315 class_bandpass (new_uri(LV2_CORE__BandpassPlugin)),
316 class_chorus (new_uri(LV2_CORE__ChorusPlugin)),
317 class_comb (new_uri(LV2_CORE__CombPlugin)),
318 class_compressor (new_uri(LV2_CORE__CompressorPlugin)),
319 class_constant (new_uri(LV2_CORE__ConstantPlugin)),
320 class_converter (new_uri(LV2_CORE__ConverterPlugin)),
321 class_delay (new_uri(LV2_CORE__DelayPlugin)),
322 class_distortion (new_uri(LV2_CORE__DistortionPlugin)),
323 class_dynamics (new_uri(LV2_CORE__DynamicsPlugin)),
324 class_eq (new_uri(LV2_CORE__EQPlugin)),
325 class_envelope (new_uri(LV2_CORE__EnvelopePlugin)),
326 class_expander (new_uri(LV2_CORE__ExpanderPlugin)),
327 class_filter (new_uri(LV2_CORE__FilterPlugin)),
328 class_flanger (new_uri(LV2_CORE__FlangerPlugin)),
329 class_function (new_uri(LV2_CORE__FunctionPlugin)),
330 class_gate (new_uri(LV2_CORE__GatePlugin)),
331 class_generator (new_uri(LV2_CORE__GeneratorPlugin)),
332 class_highpass (new_uri(LV2_CORE__HighpassPlugin)),
333 class_instrument (new_uri(LV2_CORE__InstrumentPlugin)),
334 class_limiter (new_uri(LV2_CORE__LimiterPlugin)),
335 class_lowpass (new_uri(LV2_CORE__LowpassPlugin)),
336 class_mixer (new_uri(LV2_CORE__MixerPlugin)),
337 class_modulator (new_uri(LV2_CORE__ModulatorPlugin)),
338 class_multiEQ (new_uri(LV2_CORE__MultiEQPlugin)),
339 class_oscillator (new_uri(LV2_CORE__OscillatorPlugin)),
340 class_paraEQ (new_uri(LV2_CORE__ParaEQPlugin)),
341 class_phaser (new_uri(LV2_CORE__PhaserPlugin)),
342 class_pitch (new_uri(LV2_CORE__PitchPlugin)),
343 class_reverb (new_uri(LV2_CORE__ReverbPlugin)),
344 class_simulator (new_uri(LV2_CORE__SimulatorPlugin)),
345 class_spatial (new_uri(LV2_CORE__SpatialPlugin)),
346 class_spectral (new_uri(LV2_CORE__SpectralPlugin)),
347 class_utility (new_uri(LV2_CORE__UtilityPlugin)),
348 class_waveshaper (new_uri(LV2_CORE__WaveshaperPlugin)),
349
350 port_input (new_uri(LV2_CORE__InputPort)),
351 port_output (new_uri(LV2_CORE__OutputPort)),
352 port_control (new_uri(LV2_CORE__ControlPort)),
353 port_audio (new_uri(LV2_CORE__AudioPort)),
354 port_cv (new_uri(LV2_CORE__CVPort)),
355 port_atom (new_uri(LV2_ATOM__AtomPort)),
356 port_event (new_uri(LV2_EVENT__EventPort)),
357 port_midi (new_uri(LV2_MIDI_LL__MidiPort)),
358
359 pprop_optional (new_uri(LV2_CORE__connectionOptional)),
360 pprop_enumeration (new_uri(LV2_CORE__enumeration)),
361 pprop_integer (new_uri(LV2_CORE__integer)),
362 pprop_isSideChain (new_uri(LV2_CORE__isSideChain)),
363 pprop_sampleRate (new_uri(LV2_CORE__sampleRate)),
364 pprop_toggled (new_uri(LV2_CORE__toggled)),
365 pprop_artifacts (new_uri(LV2_PORT_PROPS__causesArtifacts)),
366 pprop_continuousCV (new_uri(LV2_PORT_PROPS__continuousCV)),
367 pprop_discreteCV (new_uri(LV2_PORT_PROPS__discreteCV)),
368 pprop_expensive (new_uri(LV2_PORT_PROPS__expensive)),
369 pprop_strictBounds (new_uri(LV2_PORT_PROPS__hasStrictBounds)),
370 pprop_logarithmic (new_uri(LV2_PORT_PROPS__logarithmic)),
371 pprop_notAutomatic (new_uri(LV2_PORT_PROPS__notAutomatic)),
372 pprop_notOnGUI (new_uri(LV2_PORT_PROPS__notOnGUI)),
373 pprop_trigger (new_uri(LV2_PORT_PROPS__trigger)),
374 pprop_nonAutomatable (new_uri(LV2_KXSTUDIO_PROPERTIES__NonAutomatable)),
375
376 unit_name (new_uri(LV2_UNITS__name)),
377 unit_render (new_uri(LV2_UNITS__render)),
378 unit_symbol (new_uri(LV2_UNITS__symbol)),
379 unit_unit (new_uri(LV2_UNITS__unit)),
380
381 ui (new_uri(LV2_UI__UI)),
382 ui_gtk2 (new_uri(LV2_UI__GtkUI)),
383 ui_gtk3 (new_uri(LV2_UI__Gtk3UI)),
384 ui_qt4 (new_uri(LV2_UI__Qt4UI)),
385 ui_qt5 (new_uri(LV2_UI__Qt5UI)),
386 ui_cocoa (new_uri(LV2_UI__CocoaUI)),
387 ui_windows (new_uri(LV2_UI__WindowsUI)),
388 ui_x11 (new_uri(LV2_UI__X11UI)),
389 ui_external (new_uri(LV2_EXTERNAL_UI__Widget)),
390 ui_externalOld (new_uri(LV2_EXTERNAL_UI_DEPRECATED_URI)),
391
392 atom_bufferType (new_uri(LV2_ATOM__bufferType)),
393 atom_sequence (new_uri(LV2_ATOM__Sequence)),
394 atom_supports (new_uri(LV2_ATOM__supports)),
395
396 lv2_name (new_uri(LV2_CORE__name)),
397 lv2_symbol (new_uri(LV2_CORE__symbol)),
398 patch_readable (new_uri(LV2_PATCH__readable)),
399 patch_writable (new_uri(LV2_PATCH__writable)),
400 pg_group (new_uri(LV2_PORT_GROUPS__group)),
401 pg_sideChainOf (new_uri(LV2_PORT_GROUPS__sideChainOf)),
402 preset_preset (new_uri(LV2_PRESETS__Preset)),
403 state_state (new_uri(LV2_STATE__state)),
404
405 ui_portIndex (new_uri(LV2_UI__portIndex)),
406 ui_portNotif (new_uri(LV2_UI__portNotification)),
407 ui_protocol (new_uri(LV2_UI__protocol)),
408
409 value_default (new_uri(LV2_CORE__default)),
410 value_minimum (new_uri(LV2_CORE__minimum)),
411 value_maximum (new_uri(LV2_CORE__maximum)),
412
413 rz_asLargeAs (new_uri(LV2_RESIZE_PORT__asLargeAs)),
414 rz_minSize (new_uri(LV2_RESIZE_PORT__minimumSize)),
415
416 midi_binding (new_uri(LV2_MIDI__binding)),
417 midi_ctlrNumber (new_uri(LV2_MIDI__controllerNumber)),
418 midi_event (new_uri(LV2_MIDI__MidiEvent)),
419 patch_message (new_uri(LV2_PATCH__Message)),
420 time_position (new_uri(LV2_TIME__Position)),
421
422 mm_defaultControl (new_uri(NS_llmm "defaultMidiController")),
423 mm_controlType (new_uri(NS_llmm "controllerType")),
424 mm_controlNumber (new_uri(NS_llmm "controllerNumber")),
425
426 dct_replaces (new_uri(NS_dct "replaces")),
427 doap_license (new_uri(NS_doap "license")),
428 rdf_type (new_uri(NS_rdf "type")),
429 rdfs_comment (new_uri(NS_rdfs "comment")),
430 rdfs_label (new_uri(NS_rdfs "label")),
431 rdfs_range (new_uri(NS_rdfs "range")),
432
433 needsInit(true),
434 allPlugins(nullptr),
435 cachedPlugins(nullptr),
436 pluginCount(0) {}
437
438 ~Lv2WorldClass() override
439 {
440 pluginCount = 0;
441 allPlugins = nullptr;
442
443 if (cachedPlugins != nullptr)
444 {
445 delete[] cachedPlugins;
446 cachedPlugins = nullptr;
447 }
448 }
449
450 // FIXME - remove this
451 static Lv2WorldClass& getInstance()
452 {
453 static Lv2WorldClass lv2World;
454 return lv2World;
455 }
456
457 void initIfNeeded(const char* LV2_PATH)
458 {
459 if (LV2_PATH == nullptr || LV2_PATH[0] == '\0')
460 {
461 static const char* const DEFAULT_LV2_PATH = LILV_DEFAULT_LV2_PATH;
462 LV2_PATH = DEFAULT_LV2_PATH;
463 }
464
465 if (! needsInit)
466 return;
467
468 needsInit = false;
469
470 Lilv::World::load_all(LV2_PATH);
471
472 allPlugins = lilv_world_get_all_plugins(this->me);
473 CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr,);
474
475 if ((pluginCount = lilv_plugins_size(allPlugins)))
476 {
477 cachedPlugins = new const LilvPlugin*[pluginCount+1];
478 carla_zeroPointers(cachedPlugins, pluginCount+1);
479
480 int i = 0;
481 for (LilvIter* it = lilv_plugins_begin(allPlugins); ! lilv_plugins_is_end(allPlugins, it); it = lilv_plugins_next(allPlugins, it))
482 cachedPlugins[i++] = lilv_plugins_get(allPlugins, it);
483 }
484 }
485
486 void load_bundle(const char* const bundle)
487 {
488 CARLA_SAFE_ASSERT_RETURN(bundle != nullptr && bundle[0] != '\0',);
489 CARLA_SAFE_ASSERT_RETURN(needsInit,);
490
491 needsInit = false;
492 Lilv::World::load_bundle(Lilv::Node(new_uri(bundle)));
493
494 allPlugins = lilv_world_get_all_plugins(this->me);
495 CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr,);
496
497 if ((pluginCount = lilv_plugins_size(allPlugins)))
498 {
499 cachedPlugins = new const LilvPlugin*[pluginCount+1];
500 carla_zeroPointers(cachedPlugins, pluginCount+1);
501
502 int i = 0;
503 for (LilvIter* it = lilv_plugins_begin(allPlugins); ! lilv_plugins_is_end(allPlugins, it); it = lilv_plugins_next(allPlugins, it))
504 cachedPlugins[i++] = lilv_plugins_get(allPlugins, it);
505 }
506 }
507
508 uint getPluginCount() const
509 {
510 CARLA_SAFE_ASSERT_RETURN(! needsInit, 0);
511
512 return pluginCount;
513 }
514
515 const LilvPlugin* getPluginFromIndex(const uint index) const
516 {
517 CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);
518 CARLA_SAFE_ASSERT_RETURN(cachedPlugins != nullptr, nullptr);
519 CARLA_SAFE_ASSERT_RETURN(index < pluginCount, nullptr);
520
521 return cachedPlugins[index];
522 }
523
524 const LilvPlugin* getPluginFromURI(const LV2_URI uri) const
525 {
526 CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', nullptr);
527 CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);
528 CARLA_SAFE_ASSERT_RETURN(allPlugins != nullptr, nullptr);
529
530 LilvNode* const uriNode(lilv_new_uri(this->me, uri));
531 CARLA_SAFE_ASSERT_RETURN(uriNode != nullptr, nullptr);
532
533 const LilvPlugin* const cPlugin(lilv_plugins_get_by_uri(allPlugins, uriNode));
534 lilv_node_free(uriNode);
535
536 return cPlugin;
537 }
538
539 LilvState* getStateFromURI(const LV2_URI uri, const LV2_URID_Map* const uridMap) const
540 {
541 CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', nullptr);
542 CARLA_SAFE_ASSERT_RETURN(uridMap != nullptr, nullptr);
543 CARLA_SAFE_ASSERT_RETURN(! needsInit, nullptr);
544
545 LilvNode* const uriNode(lilv_new_uri(this->me, uri));
546 CARLA_SAFE_ASSERT_RETURN(uriNode != nullptr, nullptr);
547
548 CARLA_SAFE_ASSERT(lilv_world_load_resource(this->me, uriNode) >= 0);
549
550 LilvState* const cState(lilv_state_new_from_world(this->me, uridMap, uriNode));
551 lilv_node_free(uriNode);
552
553 return cState;
554 }
555
556 CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
557 CARLA_DECLARE_NON_COPYABLE(Lv2WorldClass)
558 };
559
560 // --------------------------------------------------------------------------------------------------------------------
561 // Our LV2 Plugin base class
562
563 #if defined(__clang__)
564 # pragma clang diagnostic push
565 # pragma clang diagnostic ignored "-Weffc++"
566 # pragma clang diagnostic ignored "-Wnon-virtual-dtor"
567 #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
568 # pragma GCC diagnostic push
569 # pragma GCC diagnostic ignored "-Weffc++"
570 # pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
571 #endif
572 template<class TimeInfoStruct>
573 class Lv2PluginBaseClass : public LV2_External_UI_Widget_Compat
574 {
575 #if defined(__clang__)
576 # pragma clang diagnostic pop
577 #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
578 # pragma GCC diagnostic pop
579 #endif
580 public:
581 Lv2PluginBaseClass(const double sampleRate, const LV2_Feature* const* const features)
582 : fIsActive(false),
583 fIsOffline(false),
584 fUsingNominal(false),
585 fBufferSize(0),
586 fSampleRate(sampleRate),
587 fFreePath(nullptr),
588 fUridMap(nullptr),
589 fUridUnmap(nullptr),
590 fWorker(nullptr),
591 fInlineDisplay(nullptr),
592 fTimeInfo(),
593 fLastPositionData(),
594 fPorts(),
595 fURIs(),
596 fUI()
597 {
598 run = extui_run;
599 show = extui_show;
600 hide = extui_hide;
601
602 if (fSampleRate < 1.0)
603 {
604 carla_stderr("Host doesn't provide a valid sample rate");
605 return;
606 }
607
608 const LV2_State_Free_Path* freePath = nullptr;
609 const LV2_Options_Option* options = nullptr;
610 const LV2_URID_Map* uridMap = nullptr;
611 const LV2_URID_Unmap* uridUnmap = nullptr;
612 const LV2_Worker_Schedule* worker = nullptr;
613 const LV2_Inline_Display* idisp = nullptr;
614
615 for (int i=0; features[i] != nullptr; ++i)
616 {
617 /**/ if (std::strcmp(features[i]->URI, LV2_STATE__freePath) == 0)
618 freePath = (const LV2_State_Free_Path*)features[i]->data;
619 else if (std::strcmp(features[i]->URI, LV2_OPTIONS__options) == 0)
620 options = (const LV2_Options_Option*)features[i]->data;
621 else if (std::strcmp(features[i]->URI, LV2_URID__map) == 0)
622 uridMap = (const LV2_URID_Map*)features[i]->data;
623 else if (std::strcmp(features[i]->URI, LV2_URID__unmap) == 0)
624 uridUnmap = (const LV2_URID_Unmap*)features[i]->data;
625 else if (std::strcmp(features[i]->URI, LV2_WORKER__schedule) == 0)
626 worker = (const LV2_Worker_Schedule*)features[i]->data;
627 else if (std::strcmp(features[i]->URI, LV2_INLINEDISPLAY__queue_draw) == 0)
628 idisp = (const LV2_Inline_Display*)features[i]->data;
629 }
630
631 if (options == nullptr || uridMap == nullptr)
632 {
633 carla_stderr("Host doesn't provide option and urid-map features");
634 return;
635 }
636
637 for (int i=0; options[i].key != 0; ++i)
638 {
639 if (uridUnmap != nullptr) {
640 carla_debug("Host option %i:\"%s\"", i, uridUnmap->unmap(uridUnmap->handle, options[i].key));
641 }
642
643 if (options[i].key == uridMap->map(uridMap->handle, LV2_BUF_SIZE__nominalBlockLength))
644 {
645 if (options[i].type == uridMap->map(uridMap->handle, LV2_ATOM__Int))
646 {
647 const int32_t value(*(const int32_t*)options[i].value);
648 CARLA_SAFE_ASSERT_CONTINUE(value > 0);
649
650 fBufferSize = static_cast<uint32_t>(value);
651 fUsingNominal = true;
652 }
653 else
654 {
655 carla_stderr("Host provides nominalBlockLength but has wrong value type");
656 }
657 break;
658 }
659
660 if (options[i].key == uridMap->map(uridMap->handle, LV2_BUF_SIZE__maxBlockLength))
661 {
662 if (options[i].type == uridMap->map(uridMap->handle, LV2_ATOM__Int))
663 {
664 const int32_t value(*(const int32_t*)options[i].value);
665 CARLA_SAFE_ASSERT_CONTINUE(value > 0);
666
667 fBufferSize = static_cast<uint32_t>(value);
668 }
669 else
670 {
671 carla_stderr("Host provides maxBlockLength but has wrong value type");
672 }
673 // no break, continue in case host supports nominalBlockLength
674 }
675 }
676
677 if (fBufferSize == 0)
678 {
679 carla_stderr("Host doesn't provide buffer-size feature");
680 //return;
681 // as testing, continue for now
682 fBufferSize = 1024;
683 }
684
685 fUridMap = uridMap;
686 fURIs.map(uridMap);
687
688 fFreePath = freePath;
689 fUridUnmap = uridUnmap;
690 fWorker = worker;
691 fInlineDisplay = idisp;
692
693 clearTimeData();
694 }
695
696 virtual ~Lv2PluginBaseClass() {}
697
698 bool loadedInProperHost() const noexcept
699 {
700 return fUridMap != nullptr && fBufferSize != 0;
701 }
702
703 // ----------------------------------------------------------------------------------------------------------------
704
705 void lv2_connect_port(const uint32_t port, void* const dataLocation) noexcept
706 {
707 fPorts.connectPort(port, dataLocation);
708 }
709
710 bool lv2_pre_run(const uint32_t frames)
711 {
712 CARLA_SAFE_ASSERT_RETURN(fIsActive, false);
713
714 fIsOffline = (fPorts.freewheel != nullptr && *fPorts.freewheel >= 0.5f);
715
716 // cache midi events and time information first
717 if (fPorts.usesTime)
718 {
719 LV2_ATOM_SEQUENCE_FOREACH(fPorts.eventsIn[0], event)
720 {
721 if (event == nullptr)
722 continue;
723 if (event->body.type != fURIs.atomBlank && event->body.type != fURIs.atomObject)
724 continue;
725
726 const LV2_Atom_Object* const obj((const LV2_Atom_Object*)&event->body);
727
728 if (obj->body.otype != fURIs.timePos)
729 continue;
730
731 LV2_Atom* bar = nullptr;
732 LV2_Atom* barBeat = nullptr;
733 LV2_Atom* beatUnit = nullptr;
734 LV2_Atom* beatsPerBar = nullptr;
735 LV2_Atom* beatsPerMinute = nullptr;
736 LV2_Atom* frame = nullptr;
737 LV2_Atom* speed = nullptr;
738 LV2_Atom* ticksPerBeat = nullptr;
739
740 lv2_atom_object_get(obj,
741 fURIs.timeBar, &bar,
742 fURIs.timeBarBeat, &barBeat,
743 fURIs.timeBeatUnit, &beatUnit,
744 fURIs.timeBeatsPerBar, &beatsPerBar,
745 fURIs.timeBeatsPerMinute, &beatsPerMinute,
746 fURIs.timeFrame, &frame,
747 fURIs.timeSpeed, &speed,
748 fURIs.timeTicksPerBeat, &ticksPerBeat,
749 0);
750
751 // need to handle this first as other values depend on it
752 if (ticksPerBeat != nullptr)
753 {
754 double ticksPerBeatValue = -1.0;
755
756 /**/ if (ticksPerBeat->type == fURIs.atomDouble)
757 ticksPerBeatValue = ((LV2_Atom_Double*)ticksPerBeat)->body;
758 else if (ticksPerBeat->type == fURIs.atomFloat)
759 ticksPerBeatValue = ((LV2_Atom_Float*)ticksPerBeat)->body;
760 else if (ticksPerBeat->type == fURIs.atomInt)
761 ticksPerBeatValue = static_cast<double>(((LV2_Atom_Int*)ticksPerBeat)->body);
762 else if (ticksPerBeat->type == fURIs.atomLong)
763 ticksPerBeatValue = static_cast<double>(((LV2_Atom_Long*)ticksPerBeat)->body);
764 else
765 carla_stderr("Unknown lv2 ticksPerBeat value type");
766
767 if (ticksPerBeatValue > 0.0)
768 fTimeInfo.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat = ticksPerBeatValue;
769 else
770 carla_stderr("Invalid lv2 ticksPerBeat value");
771 }
772
773 // same
774 if (speed != nullptr)
775 {
776 /**/ if (speed->type == fURIs.atomDouble)
777 fLastPositionData.speed = ((LV2_Atom_Double*)speed)->body;
778 else if (speed->type == fURIs.atomFloat)
779 fLastPositionData.speed = ((LV2_Atom_Float*)speed)->body;
780 else if (speed->type == fURIs.atomInt)
781 fLastPositionData.speed = static_cast<double>(((LV2_Atom_Int*)speed)->body);
782 else if (speed->type == fURIs.atomLong)
783 fLastPositionData.speed = static_cast<double>(((LV2_Atom_Long*)speed)->body);
784 else
785 carla_stderr("Unknown lv2 speed value type");
786
787 fTimeInfo.playing = carla_isNotZero(fLastPositionData.speed);
788
789 if (fTimeInfo.playing && fLastPositionData.beatsPerMinute > 0.0)
790 {
791 fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute*
792 std::abs(fLastPositionData.speed);
793 }
794 }
795
796 if (bar != nullptr)
797 {
798 int64_t barValue = -1;
799
800 /**/ if (bar->type == fURIs.atomDouble)
801 barValue = static_cast<int64_t>(((LV2_Atom_Double*)bar)->body);
802 else if (bar->type == fURIs.atomFloat)
803 barValue = static_cast<int64_t>(((LV2_Atom_Float*)bar)->body);
804 else if (bar->type == fURIs.atomInt)
805 barValue = ((LV2_Atom_Int*)bar)->body;
806 else if (bar->type == fURIs.atomLong)
807 barValue = ((LV2_Atom_Long*)bar)->body;
808 else
809 carla_stderr("Unknown lv2 bar value type");
810
811 if (barValue >= 0 && barValue < INT32_MAX)
812 {
813 fLastPositionData.bar = static_cast<int32_t>(barValue);
814 fLastPositionData.bar_f = static_cast<float>(barValue);
815 fTimeInfo.bbt.bar = fLastPositionData.bar + 1;
816 }
817 else
818 {
819 carla_stderr("Invalid lv2 bar value");
820 }
821 }
822
823 if (barBeat != nullptr)
824 {
825 double barBeatValue = -1.0;
826
827 /**/ if (barBeat->type == fURIs.atomDouble)
828 barBeatValue = ((LV2_Atom_Double*)barBeat)->body;
829 else if (barBeat->type == fURIs.atomFloat)
830 barBeatValue = ((LV2_Atom_Float*)barBeat)->body;
831 else if (barBeat->type == fURIs.atomInt)
832 barBeatValue = static_cast<float>(((LV2_Atom_Int*)barBeat)->body);
833 else if (barBeat->type == fURIs.atomLong)
834 barBeatValue = static_cast<float>(((LV2_Atom_Long*)barBeat)->body);
835 else
836 carla_stderr("Unknown lv2 barBeat value type");
837
838 if (barBeatValue >= 0.0)
839 {
840 fLastPositionData.barBeat = static_cast<float>(barBeatValue);
841
842 const double rest = std::fmod(barBeatValue, 1.0);
843 fTimeInfo.bbt.beat = static_cast<int32_t>(barBeatValue-rest+1.0);
844 fTimeInfo.bbt.tick = static_cast<int32_t>(rest*fTimeInfo.bbt.ticksPerBeat+0.5);
845 }
846 else
847 {
848 carla_stderr("Invalid lv2 barBeat value");
849 }
850 }
851
852 if (beatUnit != nullptr)
853 {
854 int64_t beatUnitValue = -1;
855
856 /**/ if (beatUnit->type == fURIs.atomDouble)
857 beatUnitValue = static_cast<int64_t>(((LV2_Atom_Double*)beatUnit)->body);
858 else if (beatUnit->type == fURIs.atomFloat)
859 beatUnitValue = static_cast<int64_t>(((LV2_Atom_Float*)beatUnit)->body);
860 else if (beatUnit->type == fURIs.atomInt)
861 beatUnitValue = ((LV2_Atom_Int*)beatUnit)->body;
862 else if (beatUnit->type == fURIs.atomLong)
863 beatUnitValue = ((LV2_Atom_Long*)beatUnit)->body;
864 else
865 carla_stderr("Unknown lv2 beatUnit value type");
866
867 if (beatUnitValue > 0 && beatUnitValue < UINT32_MAX)
868 {
869 fLastPositionData.beatUnit = static_cast<uint32_t>(beatUnitValue);
870 fTimeInfo.bbt.beatType = static_cast<float>(beatUnitValue);
871 }
872 else
873 {
874 carla_stderr("Invalid lv2 beatUnit value");
875 }
876 }
877
878 if (beatsPerBar != nullptr)
879 {
880 float beatsPerBarValue = -1.0f;
881
882 /**/ if (beatsPerBar->type == fURIs.atomDouble)
883 beatsPerBarValue = static_cast<float>(((LV2_Atom_Double*)beatsPerBar)->body);
884 else if (beatsPerBar->type == fURIs.atomFloat)
885 beatsPerBarValue = ((LV2_Atom_Float*)beatsPerBar)->body;
886 else if (beatsPerBar->type == fURIs.atomInt)
887 beatsPerBarValue = static_cast<float>(((LV2_Atom_Int*)beatsPerBar)->body);
888 else if (beatsPerBar->type == fURIs.atomLong)
889 beatsPerBarValue = static_cast<float>(((LV2_Atom_Long*)beatsPerBar)->body);
890 else
891 carla_stderr("Unknown lv2 beatsPerBar value type");
892
893 if (beatsPerBarValue > 0.0f)
894 fTimeInfo.bbt.beatsPerBar = fLastPositionData.beatsPerBar = beatsPerBarValue;
895 else
896 carla_stderr("Invalid lv2 beatsPerBar value");
897 }
898
899 if (beatsPerMinute != nullptr)
900 {
901 double beatsPerMinuteValue = -1.0;
902
903 /**/ if (beatsPerMinute->type == fURIs.atomDouble)
904 beatsPerMinuteValue = ((LV2_Atom_Double*)beatsPerMinute)->body;
905 else if (beatsPerMinute->type == fURIs.atomFloat)
906 beatsPerMinuteValue = ((LV2_Atom_Float*)beatsPerMinute)->body;
907 else if (beatsPerMinute->type == fURIs.atomInt)
908 beatsPerMinuteValue = static_cast<double>(((LV2_Atom_Int*)beatsPerMinute)->body);
909 else if (beatsPerMinute->type == fURIs.atomLong)
910 beatsPerMinuteValue = static_cast<double>(((LV2_Atom_Long*)beatsPerMinute)->body);
911 else
912 carla_stderr("Unknown lv2 beatsPerMinute value type");
913
914 if (beatsPerMinuteValue >= 12.0 && beatsPerMinuteValue <= 999.0)
915 {
916 fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute = beatsPerMinuteValue;
917
918 if (carla_isNotZero(fLastPositionData.speed))
919 fTimeInfo.bbt.beatsPerMinute *= std::abs(fLastPositionData.speed);
920 }
921 else
922 {
923 carla_stderr("Invalid lv2 beatsPerMinute value");
924 }
925 }
926
927 if (frame != nullptr)
928 {
929 int64_t frameValue = -1;
930
931 /**/ if (frame->type == fURIs.atomDouble)
932 frameValue = static_cast<int64_t>(((LV2_Atom_Double*)frame)->body);
933 else if (frame->type == fURIs.atomFloat)
934 frameValue = static_cast<int64_t>(((LV2_Atom_Float*)frame)->body);
935 else if (frame->type == fURIs.atomInt)
936 frameValue = ((LV2_Atom_Int*)frame)->body;
937 else if (frame->type == fURIs.atomLong)
938 frameValue = ((LV2_Atom_Long*)frame)->body;
939 else
940 carla_stderr("Unknown lv2 frame value type");
941
942 if (frameValue >= 0)
943 fTimeInfo.frame = fLastPositionData.frame = static_cast<uint64_t>(frameValue);
944 else
945 carla_stderr("Invalid lv2 frame value");
946 }
947
948 fTimeInfo.bbt.barStartTick = static_cast<double>(fTimeInfo.bbt.ticksPerBeat) *
949 static_cast<double>(fTimeInfo.bbt.beatsPerBar) *
950 (fTimeInfo.bbt.bar-1);
951
952 fTimeInfo.bbt.valid = (fLastPositionData.beatsPerMinute > 0.0 &&
953 fLastPositionData.beatUnit > 0 &&
954 fLastPositionData.beatsPerBar > 0.0f);
955 }
956 }
957
958 // Check for updated parameters
959 float curValue;
960
961 for (uint32_t i=0; i < fPorts.numParams; ++i)
962 {
963 if (fPorts.paramsOut[i])
964 continue;
965
966 CARLA_SAFE_ASSERT_CONTINUE(fPorts.paramsPtr[i] != nullptr)
967
968 curValue = *fPorts.paramsPtr[i];
969
970 if (carla_isEqual(fPorts.paramsLast[i], curValue))
971 continue;
972
973 fPorts.paramsLast[i] = curValue;
974 handleParameterValueChanged(i, curValue);
975 }
976
977 // init event out data
978 if (fPorts.numMidiOuts > 0 || fPorts.hasUI)
979 {
980 const uint32_t count = fPorts.numMidiOuts > 0 ? fPorts.numMidiOuts : 1;
981
982 for (uint32_t i=0; i < count; ++i)
983 {
984 LV2_Atom_Sequence* const seq(fPorts.eventsOut[i]);
985 CARLA_SAFE_ASSERT_CONTINUE(seq != nullptr);
986
987 fPorts.eventsOutData[i].capacity = seq->atom.size;
988 fPorts.eventsOutData[i].offset = 0;
989
990 seq->atom.size = sizeof(LV2_Atom_Sequence_Body);
991 seq->atom.type = fURIs.atomSequence;
992 seq->body.unit = 0;
993 seq->body.pad = 0;
994 }
995 }
996
997 if (frames == 0)
998 return false;
999
1000 return true;
1001 }
1002
1003 void lv2_post_run(const uint32_t frames)
1004 {
1005 // update timePos for next callback
1006
1007 if (carla_isZero(fLastPositionData.speed))
1008 return;
1009
1010 if (fLastPositionData.speed > 0.0)
1011 {
1012 // playing forwards
1013 fLastPositionData.frame += frames;
1014 }
1015 else
1016 {
1017 // playing backwards
1018 if (frames >= fLastPositionData.frame)
1019 fLastPositionData.frame = 0;
1020 else
1021 fLastPositionData.frame -= frames;
1022 }
1023
1024 fTimeInfo.frame = fLastPositionData.frame;
1025
1026 if (fTimeInfo.bbt.valid)
1027 {
1028 const double beatsPerMinute = fLastPositionData.beatsPerMinute * fLastPositionData.speed;
1029 const double framesPerBeat = 60.0 * fSampleRate / beatsPerMinute;
1030 const double addedBarBeats = double(frames) / framesPerBeat;
1031
1032 if (fLastPositionData.barBeat >= 0.0f)
1033 {
1034 fLastPositionData.barBeat = std::fmod(fLastPositionData.barBeat+static_cast<float>(addedBarBeats),
1035 fLastPositionData.beatsPerBar);
1036
1037 const double rest = std::fmod(fLastPositionData.barBeat, 1.0f);
1038 fTimeInfo.bbt.beat = static_cast<int32_t>(static_cast<double>(fLastPositionData.barBeat)-rest+1.0);
1039 fTimeInfo.bbt.tick = rest * fTimeInfo.bbt.ticksPerBeat;
1040
1041 if (fLastPositionData.bar_f >= 0.0f)
1042 {
1043 fLastPositionData.bar_f += std::floor((fLastPositionData.barBeat+static_cast<float>(addedBarBeats))/
1044 fLastPositionData.beatsPerBar);
1045
1046 if (fLastPositionData.bar_f <= 0.0f)
1047 {
1048 fLastPositionData.bar = 0;
1049 fLastPositionData.bar_f = 0.0f;
1050 }
1051 else
1052 {
1053 fLastPositionData.bar = static_cast<int32_t>(fLastPositionData.bar_f+0.5f);
1054 }
1055
1056 fTimeInfo.bbt.bar = fLastPositionData.bar + 1;
1057
1058 fTimeInfo.bbt.barStartTick = static_cast<double>(fTimeInfo.bbt.ticksPerBeat) *
1059 static_cast<double>(fTimeInfo.bbt.beatsPerBar) *
1060 (fTimeInfo.bbt.bar-1);
1061 }
1062 }
1063 }
1064 }
1065
1066 // ----------------------------------------------------------------------------------------------------------------
1067
1068 uint32_t lv2_get_options(LV2_Options_Option* const /*options*/) const
1069 {
1070 // currently unused
1071 return LV2_OPTIONS_SUCCESS;
1072 }
1073
1074 uint32_t lv2_set_options(const LV2_Options_Option* const options)
1075 {
1076 for (int i=0; options[i].key != 0; ++i)
1077 {
1078 if (options[i].key == fUridMap->map(fUridMap->handle, LV2_BUF_SIZE__nominalBlockLength))
1079 {
1080 if (options[i].type == fURIs.atomInt)
1081 {
1082 const int32_t value(*(const int32_t*)options[i].value);
1083 CARLA_SAFE_ASSERT_CONTINUE(value > 0);
1084
1085 const uint32_t newBufferSize = static_cast<uint32_t>(value);
1086
1087 if (fBufferSize != newBufferSize)
1088 {
1089 fBufferSize = newBufferSize;
1090 handleBufferSizeChanged(newBufferSize);
1091 }
1092 }
1093 else
1094 {
1095 carla_stderr("Host changed nominalBlockLength but with wrong value type");
1096 }
1097 }
1098 else if (options[i].key == fUridMap->map(fUridMap->handle, LV2_BUF_SIZE__maxBlockLength) && ! fUsingNominal)
1099 {
1100 if (options[i].type == fURIs.atomInt)
1101 {
1102 const int32_t value(*(const int32_t*)options[i].value);
1103 CARLA_SAFE_ASSERT_CONTINUE(value > 0);
1104
1105 const uint32_t newBufferSize = static_cast<uint32_t>(value);
1106
1107 if (fBufferSize != newBufferSize)
1108 {
1109 fBufferSize = newBufferSize;
1110 handleBufferSizeChanged(newBufferSize);
1111 }
1112 }
1113 else
1114 {
1115 carla_stderr("Host changed maxBlockLength but with wrong value type");
1116 }
1117 }
1118 else if (options[i].key == fUridMap->map(fUridMap->handle, LV2_PARAMETERS__sampleRate))
1119 {
1120 if (options[i].type == fURIs.atomFloat)
1121 {
1122 const double value(*(const float*)options[i].value);
1123 CARLA_SAFE_ASSERT_CONTINUE(value > 0.0);
1124
1125 if (carla_isNotEqual(fSampleRate, value))
1126 {
1127 fSampleRate = value;
1128 handleSampleRateChanged(value);
1129 }
1130 }
1131 else
1132 {
1133 carla_stderr("Host changed sampleRate but with wrong value type");
1134 }
1135 }
1136 }
1137
1138 return LV2_OPTIONS_SUCCESS;
1139 }
1140
1141 // ----------------------------------------------------------------------------------------------------------------
1142
1143 int lv2ui_idle() const
1144 {
1145 if (! fUI.isVisible)
1146 return 1;
1147
1148 handleUiRun();
1149 return 0;
1150 }
1151
1152 int lv2ui_show()
1153 {
1154 handleUiShow();
1155 return 0;
1156 }
1157
1158 int lv2ui_hide()
1159 {
1160 handleUiHide();
1161 return 0;
1162 }
1163
1164 void lv2ui_cleanup()
1165 {
1166 if (fUI.isVisible)
1167 handleUiHide();
1168
1169 fUI.host = nullptr;
1170 fUI.touch = nullptr;
1171 fUI.writeFunction = nullptr;
1172 fUI.controller = nullptr;
1173 }
1174
1175 // ----------------------------------------------------------------------------------------------------------------
1176
1177 protected:
1178 virtual void handleUiRun() const = 0;
1179 virtual void handleUiShow() = 0;
1180 virtual void handleUiHide() = 0;
1181
1182 virtual void handleParameterValueChanged(const uint32_t index, const float value) = 0;
1183 virtual void handleBufferSizeChanged(const uint32_t bufferSize) = 0;
1184 virtual void handleSampleRateChanged(const double sampleRate) = 0;
1185
1186 void resetTimeInfo() noexcept
1187 {
1188 clearTimeData();
1189
1190 // hosts may not send all values, resulting on some invalid data
1191 fTimeInfo.bbt.bar = 1;
1192 fTimeInfo.bbt.beat = 1;
1193 fTimeInfo.bbt.beatsPerBar = 4;
1194 fTimeInfo.bbt.beatType = 4;
1195 fTimeInfo.bbt.ticksPerBeat = fLastPositionData.ticksPerBeat = 960.0;
1196 fTimeInfo.bbt.beatsPerMinute = fLastPositionData.beatsPerMinute = 120.0;
1197 }
1198
1199 // LV2 host data
1200 bool fIsActive : 1;
1201 bool fIsOffline : 1;
1202 bool fUsingNominal : 1;
1203 uint32_t fBufferSize;
1204 double fSampleRate;
1205
1206 // LV2 host features
1207 const LV2_State_Free_Path* fFreePath;
1208 const LV2_URID_Map* fUridMap;
1209 const LV2_URID_Unmap* fUridUnmap;
1210 const LV2_Worker_Schedule* fWorker;
1211 const LV2_Inline_Display* fInlineDisplay;
1212
1213 // Time info stuff
1214 TimeInfoStruct fTimeInfo;
1215
1216 struct Lv2PositionData {
1217 int32_t bar;
1218 float bar_f;
1219 float barBeat;
1220 uint32_t beatUnit;
1221 float beatsPerBar;
1222 double beatsPerMinute;
1223 uint64_t frame;
1224 double speed;
1225 double ticksPerBeat;
1226
1227 Lv2PositionData()
1228 : bar(-1),
1229 bar_f(-1.0f),
1230 barBeat(-1.0f),
1231 beatUnit(0),
1232 beatsPerBar(0.0f),
1233 beatsPerMinute(-1.0),
1234 frame(0),
1235 speed(0.0),
1236 ticksPerBeat(-1.0) {}
1237
1238 void clear()
1239 {
1240 bar = -1;
1241 bar_f = -1.0f;
1242 barBeat = -1.0f;
1243 beatUnit = 0;
1244 beatsPerBar = 0.0f;
1245 beatsPerMinute = -1.0;
1246 frame = 0;
1247 speed = 0.0;
1248 ticksPerBeat = -1.0;
1249 }
1250
1251 } fLastPositionData;
1252
1253 // Port stuff
1254 struct Ports {
1255 // need to save current state
1256 struct EventsOutData {
1257 uint32_t capacity;
1258 uint32_t offset;
1259
1260 EventsOutData()
1261 : capacity(0),
1262 offset(0) {}
1263 };
1264
1265 // store port info
1266 uint32_t indexOffset;
1267 uint32_t numAudioIns;
1268 uint32_t numAudioOuts;
1269 uint32_t numCVIns;
1270 uint32_t numCVOuts;
1271 uint32_t numMidiIns;
1272 uint32_t numMidiOuts;
1273 uint32_t numParams;
1274 bool hasUI;
1275 bool usesTime;
1276
1277 // port buffers
1278 const LV2_Atom_Sequence** eventsIn;
1279 /* */ LV2_Atom_Sequence** eventsOut;
1280 /* */ EventsOutData* eventsOutData;
1281 /* */ float** audioCVIns;
1282 /* */ float** audioCVOuts;
1283 /* */ float* freewheel;
1284
1285 // cached parameter values
1286 float* paramsLast;
1287 float** paramsPtr;
1288 bool* paramsOut;
1289
1290 Ports()
1291 : indexOffset(0),
1292 numAudioIns(0),
1293 numAudioOuts(0),
1294 numCVIns(0),
1295 numCVOuts(0),
1296 numMidiIns(0),
1297 numMidiOuts(0),
1298 numParams(0),
1299 hasUI(false),
1300 usesTime(false),
1301 eventsIn(nullptr),
1302 eventsOut(nullptr),
1303 eventsOutData(nullptr),
1304 audioCVIns(nullptr),
1305 audioCVOuts(nullptr),
1306 freewheel(nullptr),
1307 paramsLast(nullptr),
1308 paramsPtr(nullptr),
1309 paramsOut(nullptr) {}
1310
1311 ~Ports()
1312 {
1313 if (eventsIn != nullptr)
1314 {
1315 delete[] eventsIn;
1316 eventsIn = nullptr;
1317 }
1318
1319 if (eventsOut != nullptr)
1320 {
1321 delete[] eventsOut;
1322 eventsOut = nullptr;
1323 }
1324
1325 if (eventsOutData != nullptr)
1326 {
1327 delete[] eventsOutData;
1328 eventsOutData = nullptr;
1329 }
1330
1331 if (audioCVIns != nullptr)
1332 {
1333 delete[] audioCVIns;
1334 audioCVIns = nullptr;
1335 }
1336
1337 if (audioCVOuts != nullptr)
1338 {
1339 delete[] audioCVOuts;
1340 audioCVOuts = nullptr;
1341 }
1342
1343 if (paramsLast != nullptr)
1344 {
1345 delete[] paramsLast;
1346 paramsLast = nullptr;
1347 }
1348
1349 if (paramsPtr != nullptr)
1350 {
1351 delete[] paramsPtr;
1352 paramsPtr = nullptr;
1353 }
1354
1355 if (paramsOut != nullptr)
1356 {
1357 delete[] paramsOut;
1358 paramsOut = nullptr;
1359 }
1360 }
1361
1362 // NOTE: assumes num* has been filled by parent class
1363 void init()
1364 {
1365 if (numMidiIns > 0)
1366 {
1367 eventsIn = new const LV2_Atom_Sequence*[numMidiIns];
1368
1369 for (uint32_t i=0; i < numMidiIns; ++i)
1370 eventsIn[i] = nullptr;
1371 }
1372 else if (usesTime || hasUI)
1373 {
1374 eventsIn = new const LV2_Atom_Sequence*[1];
1375 eventsIn[0] = nullptr;
1376 }
1377
1378 if (numMidiOuts > 0)
1379 {
1380 eventsOut = new LV2_Atom_Sequence*[numMidiOuts];
1381 eventsOutData = new EventsOutData[numMidiOuts];
1382
1383 for (uint32_t i=0; i < numMidiOuts; ++i)
1384 eventsOut[i] = nullptr;
1385 }
1386 else if (hasUI)
1387 {
1388 eventsOut = new LV2_Atom_Sequence*[1];
1389 eventsOut[0] = nullptr;
1390 eventsOutData = new EventsOutData[1];
1391 }
1392
1393 if (const uint32_t numAudioCVIns = numAudioIns+numCVIns)
1394 {
1395 audioCVIns = new float*[numAudioCVIns];
1396 carla_zeroPointers(audioCVIns, numAudioCVIns);
1397 }
1398
1399 if (const uint32_t numAudioCVOuts = numAudioOuts+numCVOuts)
1400 {
1401 audioCVOuts = new float*[numAudioCVOuts];
1402 carla_zeroPointers(audioCVOuts, numAudioCVOuts);
1403 }
1404
1405 if (numParams > 0)
1406 {
1407 paramsLast = new float[numParams];
1408 paramsPtr = new float*[numParams];
1409 paramsOut = new bool[numParams];
1410
1411 carla_zeroFloats(paramsLast, numParams);
1412 carla_zeroPointers(paramsPtr, numParams);
1413 carla_zeroStructs(paramsOut, numParams);
1414
1415 // NOTE: need to be filled in by the parent class
1416 }
1417
1418 indexOffset = numAudioIns + numAudioOuts + numCVIns + numCVOuts;
1419 // 1 event port for time or ui if no midi input is used
1420 indexOffset += numMidiIns > 0 ? numMidiIns : ((usesTime || hasUI) ? 1 : 0);
1421 // 1 event port for ui if no midi output is used
1422 indexOffset += numMidiOuts > 0 ? numMidiOuts : (hasUI ? 1 : 0);
1423 // 1 extra for freewheel port
1424 indexOffset += 1;
1425 }
1426
1427 void connectPort(const uint32_t port, void* const dataLocation)
1428 {
1429 uint32_t index = 0;
1430
1431 if (numMidiIns > 0 || usesTime || hasUI)
1432 {
1433 if (port == index++)
1434 {
1435 eventsIn[0] = (LV2_Atom_Sequence*)dataLocation;
1436 return;
1437 }
1438 }
1439
1440 for (uint32_t i=1; i < numMidiIns; ++i)
1441 {
1442 if (port == index++)
1443 {
1444 eventsIn[i] = (LV2_Atom_Sequence*)dataLocation;
1445 return;
1446 }
1447 }
1448
1449 if (numMidiOuts > 0 || hasUI)
1450 {
1451 if (port == index++)
1452 {
1453 eventsOut[0] = (LV2_Atom_Sequence*)dataLocation;
1454 return;
1455 }
1456 }
1457
1458 for (uint32_t i=1; i < numMidiOuts; ++i)
1459 {
1460 if (port == index++)
1461 {
1462 eventsOut[i] = (LV2_Atom_Sequence*)dataLocation;
1463 return;
1464 }
1465 }
1466
1467 if (port == index++)
1468 {
1469 freewheel = (float*)dataLocation;
1470 return;
1471 }
1472
1473 for (uint32_t i=0; i < numAudioIns; ++i)
1474 {
1475 if (port == index++)
1476 {
1477 audioCVIns[i] = (float*)dataLocation;
1478 return;
1479 }
1480 }
1481
1482 for (uint32_t i=0; i < numAudioOuts; ++i)
1483 {
1484 if (port == index++)
1485 {
1486 audioCVOuts[i] = (float*)dataLocation;
1487 return;
1488 }
1489 }
1490
1491 for (uint32_t i=0; i < numCVIns; ++i)
1492 {
1493 if (port == index++)
1494 {
1495 audioCVIns[numAudioIns+i] = (float*)dataLocation;
1496 return;
1497 }
1498 }
1499
1500 for (uint32_t i=0; i < numCVOuts; ++i)
1501 {
1502 if (port == index++)
1503 {
1504 audioCVOuts[numAudioOuts+i] = (float*)dataLocation;
1505 return;
1506 }
1507 }
1508
1509 for (uint32_t i=0; i < numParams; ++i)
1510 {
1511 if (port == index++)
1512 {
1513 paramsPtr[i] = (float*)dataLocation;
1514 return;
1515 }
1516 }
1517 }
1518
1519 CARLA_DECLARE_NON_COPYABLE(Ports);
1520 } fPorts;
1521
1522 // Rest of host<->plugin support
1523 struct URIDs {
1524 LV2_URID atomBlank;
1525 LV2_URID atomBool;
1526 LV2_URID atomObject;
1527 LV2_URID atomDouble;
1528 LV2_URID atomFloat;
1529 LV2_URID atomInt;
1530 LV2_URID atomLong;
1531 LV2_URID atomPath;
1532 LV2_URID atomSequence;
1533 LV2_URID atomString;
1534 LV2_URID atomURID;
1535 LV2_URID carlaFile;
1536 LV2_URID carlaFileAudio;
1537 LV2_URID carlaFileMIDI;
1538 LV2_URID carlaPreview;
1539 LV2_URID midiEvent;
1540 LV2_URID patchProperty;
1541 LV2_URID patchGet;
1542 LV2_URID patchSet;
1543 LV2_URID patchValue;
1544 LV2_URID timePos;
1545 LV2_URID timeBar;
1546 LV2_URID timeBarBeat;
1547 LV2_URID timeBeatsPerBar;
1548 LV2_URID timeBeatsPerMinute;
1549 LV2_URID timeBeatUnit;
1550 LV2_URID timeFrame;
1551 LV2_URID timeSpeed;
1552 LV2_URID timeTicksPerBeat;
1553 LV2_URID carlaRequestIdle;
1554 LV2_URID carlaUiEvents;
1555
1556 URIDs()
1557 : atomBlank(0),
1558 atomBool(0),
1559 atomObject(0),
1560 atomDouble(0),
1561 atomFloat(0),
1562 atomInt(0),
1563 atomLong(0),
1564 atomPath(0),
1565 atomSequence(0),
1566 atomString(0),
1567 atomURID(0),
1568 carlaFile(0),
1569 carlaFileAudio(0),
1570 carlaFileMIDI(0),
1571 carlaPreview(0),
1572 midiEvent(0),
1573 patchProperty(0),
1574 patchGet(0),
1575 patchSet(0),
1576 patchValue(0),
1577 timePos(0),
1578 timeBar(0),
1579 timeBarBeat(0),
1580 timeBeatsPerBar(0),
1581 timeBeatsPerMinute(0),
1582 timeBeatUnit(0),
1583 timeFrame(0),
1584 timeSpeed(0),
1585 timeTicksPerBeat(0),
1586 carlaRequestIdle(0),
1587 carlaUiEvents(0) {}
1588
1589 void map(const LV2_URID_Map* const uridMap)
1590 {
1591 atomBlank = uridMap->map(uridMap->handle, LV2_ATOM__Blank);
1592 atomBool = uridMap->map(uridMap->handle, LV2_ATOM__Bool);
1593 atomObject = uridMap->map(uridMap->handle, LV2_ATOM__Object);
1594 atomDouble = uridMap->map(uridMap->handle, LV2_ATOM__Double);
1595 atomFloat = uridMap->map(uridMap->handle, LV2_ATOM__Float);
1596 atomInt = uridMap->map(uridMap->handle, LV2_ATOM__Int);
1597 atomLong = uridMap->map(uridMap->handle, LV2_ATOM__Long);
1598 atomPath = uridMap->map(uridMap->handle, LV2_ATOM__Path);
1599 atomSequence = uridMap->map(uridMap->handle, LV2_ATOM__Sequence);
1600 atomString = uridMap->map(uridMap->handle, LV2_ATOM__String);
1601 atomURID = uridMap->map(uridMap->handle, LV2_ATOM__URID);
1602 carlaFile = uridMap->map(uridMap->handle, "http://kxstudio.sf.net/carla/file");
1603 carlaFileAudio = uridMap->map(uridMap->handle, "http://kxstudio.sf.net/carla/file/audio");
1604 carlaFileMIDI = uridMap->map(uridMap->handle, "http://kxstudio.sf.net/carla/file/midi");
1605 carlaPreview = uridMap->map(uridMap->handle, "http://kxstudio.sf.net/carla/preview");
1606 midiEvent = uridMap->map(uridMap->handle, LV2_MIDI__MidiEvent);
1607 patchProperty = uridMap->map(uridMap->handle, LV2_PATCH__property);
1608 patchGet = uridMap->map(uridMap->handle, LV2_PATCH__Get);
1609 patchSet = uridMap->map(uridMap->handle, LV2_PATCH__Set);
1610 patchValue = uridMap->map(uridMap->handle, LV2_PATCH__value);
1611 timePos = uridMap->map(uridMap->handle, LV2_TIME__Position);
1612 timeBar = uridMap->map(uridMap->handle, LV2_TIME__bar);
1613 timeBarBeat = uridMap->map(uridMap->handle, LV2_TIME__barBeat);
1614 timeBeatUnit = uridMap->map(uridMap->handle, LV2_TIME__beatUnit);
1615 timeFrame = uridMap->map(uridMap->handle, LV2_TIME__frame);
1616 timeSpeed = uridMap->map(uridMap->handle, LV2_TIME__speed);
1617 timeBeatsPerBar = uridMap->map(uridMap->handle, LV2_TIME__beatsPerBar);
1618 timeBeatsPerMinute = uridMap->map(uridMap->handle, LV2_TIME__beatsPerMinute);
1619 timeTicksPerBeat = uridMap->map(uridMap->handle, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat);
1620 carlaRequestIdle = uridMap->map(uridMap->handle, "urn:carla:idle");
1621 carlaUiEvents = uridMap->map(uridMap->handle, "urn:carla:uiEvents");
1622 }
1623 } fURIs;
1624
1625 struct UI {
1626 const LV2_External_UI_Host* host;
1627 const LV2UI_Touch* touch;
1628 LV2UI_Write_Function writeFunction;
1629 LV2UI_Controller controller;
1630 bool isVisible;
1631
1632 UI()
1633 : host(nullptr),
1634 touch(nullptr),
1635 writeFunction(nullptr),
1636 controller(nullptr),
1637 isVisible(false) {}
1638 } fUI;
1639
1640 private:
1641 // ----------------------------------------------------------------------------------------------------------------
1642
1643 #define handlePtr ((Lv2PluginBaseClass*)handle)
1644
1645 static void extui_run(LV2_External_UI_Widget_Compat* handle)
1646 {
1647 CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
1648
1649 handlePtr->handleUiRun();
1650 }
1651
1652 static void extui_show(LV2_External_UI_Widget_Compat* handle)
1653 {
1654 CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
1655 carla_debug("extui_show(%p)", handle);
1656
1657 handlePtr->handleUiShow();
1658 }
1659
1660 static void extui_hide(LV2_External_UI_Widget_Compat* handle)
1661 {
1662 CARLA_SAFE_ASSERT_RETURN(handle != nullptr,);
1663 carla_debug("extui_hide(%p)", handle);
1664
1665 handlePtr->handleUiHide();
1666 }
1667
1668 #undef handlePtr
1669
1670 // ----------------------------------------------------------------------------------------------------------------
1671
1672 void clearTimeData() noexcept;
1673
1674 // ----------------------------------------------------------------------------------------------------------------
1675
1676 CARLA_DECLARE_NON_COPYABLE(Lv2PluginBaseClass)
1677 };
1678
1679 // --------------------------------------------------------------------------------------------------------------------
1680 // Create new RDF object (using lilv)
1681
1682 static inline
1683 const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI uri, const bool loadPresets)
1684 {
1685 CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', nullptr);
1686
1687 Lv2WorldClass& lv2World(Lv2WorldClass::getInstance());
1688
1689 const LilvPlugin* const cPlugin(lv2World.getPluginFromURI(uri));
1690 CARLA_SAFE_ASSERT_RETURN(cPlugin != nullptr, nullptr);
1691
1692 Lilv::Plugin lilvPlugin(cPlugin);
1693 LV2_RDF_Descriptor* const rdfDescriptor(new LV2_RDF_Descriptor());
1694
1695 CarlaStringList portGroupURIs(false); // does not allocate own elements
1696 LinkedList<LilvNode*> portGroupNodes;
1697
1698 // ----------------------------------------------------------------------------------------------------------------
1699 // Set Plugin Type
1700 {
1701 Lilv::Nodes typeNodes(lilvPlugin.get_value(lv2World.rdf_type));
1702
1703 if (typeNodes.size() > 0)
1704 {
1705 if (typeNodes.contains(lv2World.class_allpass))
1706 rdfDescriptor->Type[0] |= LV2_PLUGIN_ALLPASS;
1707 if (typeNodes.contains(lv2World.class_amplifier))
1708 rdfDescriptor->Type[0] |= LV2_PLUGIN_AMPLIFIER;
1709 if (typeNodes.contains(lv2World.class_analyzer))
1710 rdfDescriptor->Type[1] |= LV2_PLUGIN_ANALYSER;
1711 if (typeNodes.contains(lv2World.class_bandpass))
1712 rdfDescriptor->Type[0] |= LV2_PLUGIN_BANDPASS;
1713 if (typeNodes.contains(lv2World.class_chorus))
1714 rdfDescriptor->Type[1] |= LV2_PLUGIN_CHORUS;
1715 if (typeNodes.contains(lv2World.class_comb))
1716 rdfDescriptor->Type[1] |= LV2_PLUGIN_COMB;
1717 if (typeNodes.contains(lv2World.class_compressor))
1718 rdfDescriptor->Type[0] |= LV2_PLUGIN_COMPRESSOR;
1719 if (typeNodes.contains(lv2World.class_constant))
1720 rdfDescriptor->Type[1] |= LV2_PLUGIN_CONSTANT;
1721 if (typeNodes.contains(lv2World.class_converter))
1722 rdfDescriptor->Type[1] |= LV2_PLUGIN_CONVERTER;
1723 if (typeNodes.contains(lv2World.class_delay))
1724 rdfDescriptor->Type[0] |= LV2_PLUGIN_DELAY;
1725 if (typeNodes.contains(lv2World.class_distortion))
1726 rdfDescriptor->Type[0] |= LV2_PLUGIN_DISTORTION;
1727 if (typeNodes.contains(lv2World.class_dynamics))
1728 rdfDescriptor->Type[0] |= LV2_PLUGIN_DYNAMICS;
1729 if (typeNodes.contains(lv2World.class_eq))
1730 rdfDescriptor->Type[0] |= LV2_PLUGIN_EQ;
1731 if (typeNodes.contains(lv2World.class_envelope))
1732 rdfDescriptor->Type[0] |= LV2_PLUGIN_ENVELOPE;
1733 if (typeNodes.contains(lv2World.class_expander))
1734 rdfDescriptor->Type[0] |= LV2_PLUGIN_EXPANDER;
1735 if (typeNodes.contains(lv2World.class_filter))
1736 rdfDescriptor->Type[0] |= LV2_PLUGIN_FILTER;
1737 if (typeNodes.contains(lv2World.class_flanger))
1738 rdfDescriptor->Type[1] |= LV2_PLUGIN_FLANGER;
1739 if (typeNodes.contains(lv2World.class_function))
1740 rdfDescriptor->Type[1] |= LV2_PLUGIN_FUNCTION;
1741 if (typeNodes.contains(lv2World.class_gate))
1742 rdfDescriptor->Type[0] |= LV2_PLUGIN_GATE;
1743 if (typeNodes.contains(lv2World.class_generator))
1744 rdfDescriptor->Type[1] |= LV2_PLUGIN_GENERATOR;
1745 if (typeNodes.contains(lv2World.class_highpass))
1746 rdfDescriptor->Type[0] |= LV2_PLUGIN_HIGHPASS;
1747 if (typeNodes.contains(lv2World.class_instrument))
1748 rdfDescriptor->Type[1] |= LV2_PLUGIN_INSTRUMENT;
1749 if (typeNodes.contains(lv2World.class_limiter))
1750 rdfDescriptor->Type[0] |= LV2_PLUGIN_LIMITER;
1751 if (typeNodes.contains(lv2World.class_lowpass))
1752 rdfDescriptor->Type[0] |= LV2_PLUGIN_LOWPASS;
1753 if (typeNodes.contains(lv2World.class_mixer))
1754 rdfDescriptor->Type[1] |= LV2_PLUGIN_MIXER;
1755 if (typeNodes.contains(lv2World.class_modulator))
1756 rdfDescriptor->Type[1] |= LV2_PLUGIN_MODULATOR;
1757 if (typeNodes.contains(lv2World.class_multiEQ))
1758 rdfDescriptor->Type[0] |= LV2_PLUGIN_MULTI_EQ;
1759 if (typeNodes.contains(lv2World.class_oscillator))
1760 rdfDescriptor->Type[1] |= LV2_PLUGIN_OSCILLATOR;
1761 if (typeNodes.contains(lv2World.class_paraEQ))
1762 rdfDescriptor->Type[0] |= LV2_PLUGIN_PARA_EQ;
1763 if (typeNodes.contains(lv2World.class_phaser))
1764 rdfDescriptor->Type[1] |= LV2_PLUGIN_PHASER;
1765 if (typeNodes.contains(lv2World.class_pitch))
1766 rdfDescriptor->Type[1] |= LV2_PLUGIN_PITCH;
1767 if (typeNodes.contains(lv2World.class_reverb))
1768 rdfDescriptor->Type[0] |= LV2_PLUGIN_REVERB;
1769 if (typeNodes.contains(lv2World.class_simulator))
1770 rdfDescriptor->Type[0] |= LV2_PLUGIN_SIMULATOR;
1771 if (typeNodes.contains(lv2World.class_spatial))
1772 rdfDescriptor->Type[1] |= LV2_PLUGIN_SPATIAL;
1773 if (typeNodes.contains(lv2World.class_spectral))
1774 rdfDescriptor->Type[1] |= LV2_PLUGIN_SPECTRAL;
1775 if (typeNodes.contains(lv2World.class_utility))
1776 rdfDescriptor->Type[1] |= LV2_PLUGIN_UTILITY;
1777 if (typeNodes.contains(lv2World.class_waveshaper))
1778 rdfDescriptor->Type[0] |= LV2_PLUGIN_WAVESHAPER;
1779 }
1780
1781 lilv_nodes_free(const_cast<LilvNodes*>(typeNodes.me));
1782 }
1783
1784 // ----------------------------------------------------------------------------------------------------------------
1785 // Set Plugin Information
1786 {
1787 rdfDescriptor->URI = carla_strdup(uri);
1788
1789 if (LilvNode* const nameNode = lilv_plugin_get_name(lilvPlugin.me))
1790 {
1791 if (const char* const name = lilv_node_as_string(nameNode))
1792 rdfDescriptor->Name = carla_strdup(name);
1793 lilv_node_free(nameNode);
1794 }
1795
1796 if (const char* const author = lilvPlugin.get_author_name().as_string())
1797 rdfDescriptor->Author = carla_strdup(author);
1798
1799 if (const char* const binary = lilvPlugin.get_library_uri().as_string())
1800 rdfDescriptor->Binary = carla_strdup_free(lilv_file_uri_parse(binary, nullptr));
1801
1802 if (const char* const bundle = lilvPlugin.get_bundle_uri().as_string())
1803 rdfDescriptor->Bundle = carla_strdup_free(lilv_file_uri_parse(bundle, nullptr));
1804
1805 Lilv::Nodes licenseNodes(lilvPlugin.get_value(lv2World.doap_license));
1806
1807 if (licenseNodes.size() > 0)
1808 {
1809 if (const char* const license = licenseNodes.get_first().as_string())
1810 rdfDescriptor->License = carla_strdup(license);
1811 }
1812
1813 lilv_nodes_free(const_cast<LilvNodes*>(licenseNodes.me));
1814 }
1815
1816 // ----------------------------------------------------------------------------------------------------------------
1817 // Set Plugin UniqueID
1818 {
1819 Lilv::Nodes replaceNodes(lilvPlugin.get_value(lv2World.dct_replaces));
1820
1821 if (replaceNodes.size() > 0)
1822 {
1823 Lilv::Node replaceNode(replaceNodes.get_first());
1824
1825 if (replaceNode.is_uri())
1826 {
1827 #if defined(CARLA_UTILS_USE_QT)
1828 const QString replaceURI(replaceNode.as_uri());
1829
1830 if (replaceURI.startsWith("urn:"))
1831 {
1832 const QString replaceId(replaceURI.split(":").last());
1833
1834 bool ok;
1835 const ulong uniqueId(replaceId.toULong(&ok));
1836
1837 if (ok && uniqueId != 0)
1838 rdfDescriptor->UniqueID = uniqueId;
1839 }
1840 #else
1841 const water::String replaceURI(replaceNode.as_uri());
1842
1843 if (replaceURI.startsWith("urn:"))
1844 {
1845 const int uniqueId(replaceURI.getTrailingIntValue());
1846
1847 if (uniqueId > 0)
1848 rdfDescriptor->UniqueID = static_cast<ulong>(uniqueId);
1849 }
1850 #endif
1851 }
1852 }
1853
1854 lilv_nodes_free(const_cast<LilvNodes*>(replaceNodes.me));
1855 }
1856
1857 // ----------------------------------------------------------------------------------------------------------------
1858 // Set Plugin Ports
1859
1860 if (const uint numPorts = lilvPlugin.get_num_ports())
1861 {
1862 rdfDescriptor->PortCount = numPorts;
1863 rdfDescriptor->Ports = new LV2_RDF_Port[numPorts];
1864
1865 for (uint i = 0; i < numPorts; ++i)
1866 {
1867 Lilv::Port lilvPort(lilvPlugin.get_port_by_index(i));
1868 CARLA_SAFE_ASSERT_CONTINUE(lilvPort.me != nullptr);
1869
1870 LV2_RDF_Port* const rdfPort(&rdfDescriptor->Ports[i]);
1871
1872 // --------------------------------------------------------------------------------------------------------
1873 // Set Port Information
1874 {
1875 if (LilvNode* const nameNode = lilv_port_get_name(lilvPlugin.me, lilvPort.me))
1876 {
1877 if (const char* const name = lilv_node_as_string(nameNode))
1878 rdfPort->Name = carla_strdup(name);
1879 lilv_node_free(nameNode);
1880 }
1881
1882 if (const char* const symbol = lilv_node_as_string(lilvPort.get_symbol()))
1883 rdfPort->Symbol = carla_strdup(symbol);
1884
1885 if (LilvNode* const commentNode = lilvPort.get(lv2World.rdfs_comment.me))
1886 {
1887 rdfPort->Comment = carla_strdup(lilv_node_as_string(commentNode));
1888 lilv_node_free(commentNode);
1889 }
1890
1891 if (LilvNode* const groupNode = lilvPort.get(lv2World.pg_group.me))
1892 {
1893 rdfPort->GroupURI = carla_strdup(lilv_node_as_uri(groupNode));
1894
1895 if (portGroupURIs.appendUnique(rdfPort->GroupURI))
1896 portGroupNodes.append(groupNode);
1897 else
1898 lilv_node_free(groupNode);
1899 }
1900 }
1901
1902 // --------------------------------------------------------------------------------------------------------
1903 // Set Port Mode and Type
1904 {
1905 // Input or Output
1906 /**/ if (lilvPort.is_a(lv2World.port_input))
1907 rdfPort->Types |= LV2_PORT_INPUT;
1908 else if (lilvPort.is_a(lv2World.port_output))
1909 rdfPort->Types |= LV2_PORT_OUTPUT;
1910 else
1911 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is not input or output", uri, rdfPort->Name);
1912
1913 // Data Type
1914 /**/ if (lilvPort.is_a(lv2World.port_control))
1915 {
1916 rdfPort->Types |= LV2_PORT_CONTROL;
1917 }
1918 else if (lilvPort.is_a(lv2World.port_audio))
1919 {
1920 rdfPort->Types |= LV2_PORT_AUDIO;
1921 }
1922 else if (lilvPort.is_a(lv2World.port_cv))
1923 {
1924 rdfPort->Types |= LV2_PORT_CV;
1925 }
1926 else if (lilvPort.is_a(lv2World.port_atom))
1927 {
1928 rdfPort->Types |= LV2_PORT_ATOM;
1929
1930 Lilv::Nodes bufferTypeNodes(lilvPort.get_value(lv2World.atom_bufferType));
1931
1932 for (LilvIter* it = lilv_nodes_begin(bufferTypeNodes.me); ! lilv_nodes_is_end(bufferTypeNodes.me, it); it = lilv_nodes_next(bufferTypeNodes.me, it))
1933 {
1934 const Lilv::Node node(lilv_nodes_get(bufferTypeNodes.me, it));
1935 CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());
1936
1937 if (node.equals(lv2World.atom_sequence))
1938 rdfPort->Types |= LV2_PORT_ATOM_SEQUENCE;
1939 else
1940 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses an unknown atom buffer type '%s'", uri, rdfPort->Name, node.as_uri());
1941 }
1942
1943 Lilv::Nodes supportNodes(lilvPort.get_value(lv2World.atom_supports));
1944
1945 for (LilvIter* it = lilv_nodes_begin(supportNodes.me); ! lilv_nodes_is_end(supportNodes.me, it); it = lilv_nodes_next(supportNodes.me, it))
1946 {
1947 const Lilv::Node node(lilv_nodes_get(supportNodes.me, it));
1948 CARLA_SAFE_ASSERT_CONTINUE(node.is_uri());
1949
1950 /**/ if (node.equals(lv2World.midi_event))
1951 rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;
1952
1953 else if (node.equals(lv2World.patch_message))
1954 rdfPort->Types |= LV2_PORT_DATA_PATCH_MESSAGE;
1955
1956 else if (node.equals(lv2World.time_position))
1957 rdfPort->Types |= LV2_PORT_DATA_TIME_POSITION;
1958
1959 #if 0
1960 // something new we don't support yet?
1961 else if (std::strstr(node.as_uri(), "lv2plug.in/") != nullptr)
1962 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is of atom type but has unsupported data '%s'", uri, rdfPort->Name, node.as_uri());
1963 #endif
1964 }
1965
1966 lilv_nodes_free(const_cast<LilvNodes*>(bufferTypeNodes.me));
1967 lilv_nodes_free(const_cast<LilvNodes*>(supportNodes.me));
1968 }
1969 else if (lilvPort.is_a(lv2World.port_event))
1970 {
1971 rdfPort->Types |= LV2_PORT_EVENT;
1972 bool supported = false;
1973
1974 if (lilvPort.supports_event(lv2World.midi_event))
1975 {
1976 rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;
1977 supported = true;
1978 }
1979 if (lilvPort.supports_event(lv2World.patch_message))
1980 {
1981 rdfPort->Types |= LV2_PORT_DATA_PATCH_MESSAGE;
1982 supported = true;
1983 }
1984 if (lilvPort.supports_event(lv2World.time_position))
1985 {
1986 rdfPort->Types |= LV2_PORT_DATA_TIME_POSITION;
1987 supported = true;
1988 }
1989
1990 if (! supported)
1991 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is of event type but has unsupported data", uri, rdfPort->Name);
1992 }
1993 else if (lilvPort.is_a(lv2World.port_midi))
1994 {
1995 rdfPort->Types |= LV2_PORT_MIDI_LL;
1996 rdfPort->Types |= LV2_PORT_DATA_MIDI_EVENT;
1997 }
1998 else
1999 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' is of unknown data type", uri, rdfPort->Name);
2000 }
2001
2002 // --------------------------------------------------------------------------------------------------------
2003 // Set Port Properties
2004 {
2005 if (lilvPort.has_property(lv2World.pprop_optional))
2006 rdfPort->Properties |= LV2_PORT_OPTIONAL;
2007 if (lilvPort.has_property(lv2World.pprop_enumeration))
2008 rdfPort->Properties |= LV2_PORT_ENUMERATION;
2009 if (lilvPort.has_property(lv2World.pprop_integer))
2010 rdfPort->Properties |= LV2_PORT_INTEGER;
2011 if (lilvPort.has_property(lv2World.pprop_isSideChain))
2012 rdfPort->Properties |= LV2_PORT_SIDECHAIN;
2013 if (lilvPort.has_property(lv2World.pprop_sampleRate))
2014 rdfPort->Properties |= LV2_PORT_SAMPLE_RATE;
2015 if (lilvPort.has_property(lv2World.pprop_toggled))
2016 rdfPort->Properties |= LV2_PORT_TOGGLED;
2017
2018 if (lilvPort.has_property(lv2World.pprop_artifacts))
2019 rdfPort->Properties |= LV2_PORT_CAUSES_ARTIFACTS;
2020 if (lilvPort.has_property(lv2World.pprop_continuousCV))
2021 rdfPort->Properties |= LV2_PORT_CONTINUOUS_CV;
2022 if (lilvPort.has_property(lv2World.pprop_discreteCV))
2023 rdfPort->Properties |= LV2_PORT_DISCRETE_CV;
2024 if (lilvPort.has_property(lv2World.pprop_expensive))
2025 rdfPort->Properties |= LV2_PORT_EXPENSIVE;
2026 if (lilvPort.has_property(lv2World.pprop_strictBounds))
2027 rdfPort->Properties |= LV2_PORT_STRICT_BOUNDS;
2028 if (lilvPort.has_property(lv2World.pprop_logarithmic))
2029 rdfPort->Properties |= LV2_PORT_LOGARITHMIC;
2030 if (lilvPort.has_property(lv2World.pprop_notAutomatic))
2031 rdfPort->Properties |= LV2_PORT_NOT_AUTOMATIC;
2032 if (lilvPort.has_property(lv2World.pprop_notOnGUI))
2033 rdfPort->Properties |= LV2_PORT_NOT_ON_GUI;
2034 if (lilvPort.has_property(lv2World.pprop_trigger))
2035 rdfPort->Properties |= LV2_PORT_TRIGGER;
2036 if (lilvPort.has_property(lv2World.pprop_nonAutomatable))
2037 rdfPort->Properties |= LV2_PORT_NON_AUTOMATABLE;
2038
2039 if (lilvPort.has_property(lv2World.reportsLatency))
2040 rdfPort->Designation = LV2_PORT_DESIGNATION_LATENCY;
2041
2042 // check if sidechain (some plugins use sidechain groups instead of isSidechain)
2043 if (LilvNode* const portGroupNode = lilvPort.get(lv2World.pg_group.me))
2044 {
2045 if (LilvNode* const portSideChainOfNode = lilv_world_get(lv2World.me, portGroupNode,
2046 lv2World.pg_sideChainOf.me, nullptr))
2047 {
2048 rdfPort->Properties |= LV2_PORT_SIDECHAIN;
2049 lilv_node_free(portSideChainOfNode);
2050 }
2051 lilv_node_free(portGroupNode);
2052 }
2053
2054 // no port properties set, check if using old/invalid ones
2055 if (rdfPort->Properties == 0x0)
2056 {
2057 const Lilv::Node oldPropArtifacts(lv2World.new_uri(NS_devp "causesArtifacts"));
2058 const Lilv::Node oldPropContinuousCV(lv2World.new_uri(NS_devp "continuousCV"));
2059 const Lilv::Node oldPropDiscreteCV(lv2World.new_uri(NS_devp "discreteCV"));
2060 const Lilv::Node oldPropExpensive(lv2World.new_uri(NS_devp "expensive"));
2061 const Lilv::Node oldPropStrictBounds(lv2World.new_uri(NS_devp "hasStrictBounds"));
2062 const Lilv::Node oldPropLogarithmic(lv2World.new_uri(NS_devp "logarithmic"));
2063 const Lilv::Node oldPropNotAutomatic(lv2World.new_uri(NS_devp "notAutomatic"));
2064 const Lilv::Node oldPropNotOnGUI(lv2World.new_uri(NS_devp "notOnGUI"));
2065 const Lilv::Node oldPropTrigger(lv2World.new_uri(NS_devp "trigger"));
2066
2067 if (lilvPort.has_property(oldPropArtifacts))
2068 {
2069 rdfPort->Properties |= LV2_PORT_CAUSES_ARTIFACTS;
2070 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'causesArtifacts'", uri, rdfPort->Name);
2071 }
2072 if (lilvPort.has_property(oldPropContinuousCV))
2073 {
2074 rdfPort->Properties |= LV2_PORT_CONTINUOUS_CV;
2075 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'continuousCV'", uri, rdfPort->Name);
2076 }
2077 if (lilvPort.has_property(oldPropDiscreteCV))
2078 {
2079 rdfPort->Properties |= LV2_PORT_DISCRETE_CV;
2080 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'discreteCV'", uri, rdfPort->Name);
2081 }
2082 if (lilvPort.has_property(oldPropExpensive))
2083 {
2084 rdfPort->Properties |= LV2_PORT_EXPENSIVE;
2085 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'expensive'", uri, rdfPort->Name);
2086 }
2087 if (lilvPort.has_property(oldPropStrictBounds))
2088 {
2089 rdfPort->Properties |= LV2_PORT_STRICT_BOUNDS;
2090 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'hasStrictBounds'", uri, rdfPort->Name);
2091 }
2092 if (lilvPort.has_property(oldPropLogarithmic))
2093 {
2094 rdfPort->Properties |= LV2_PORT_LOGARITHMIC;
2095 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'logarithmic'", uri, rdfPort->Name);
2096 }
2097 if (lilvPort.has_property(oldPropNotAutomatic))
2098 {
2099 rdfPort->Properties |= LV2_PORT_NOT_AUTOMATIC;
2100 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'notAutomatic'", uri, rdfPort->Name);
2101 }
2102 if (lilvPort.has_property(oldPropNotOnGUI))
2103 {
2104 rdfPort->Properties |= LV2_PORT_NOT_ON_GUI;
2105 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'notOnGUI'", uri, rdfPort->Name);
2106 }
2107 if (lilvPort.has_property(oldPropTrigger))
2108 {
2109 rdfPort->Properties |= LV2_PORT_TRIGGER;
2110 carla_stderr("lv2_rdf_new(\"%s\") - port '%s' uses old/invalid LV2 property for 'trigger'", uri, rdfPort->Name);
2111 }
2112 }
2113 }
2114
2115 // --------------------------------------------------------------------------------------------------------
2116 // Set Port Designation
2117 {
2118 if (LilvNode* const designationNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.designation.me))
2119 {
2120 if (const char* const designation = lilv_node_as_string(designationNode))
2121 {
2122 /**/ if (std::strcmp(designation, LV2_CORE__control) == 0)
2123 rdfPort->Designation = LV2_PORT_DESIGNATION_CONTROL;
2124 else if (std::strcmp(designation, LV2_CORE__enabled) == 0)
2125 rdfPort->Designation = LV2_PORT_DESIGNATION_ENABLED;
2126 else if (std::strcmp(designation, LV2_CORE__freeWheeling) == 0)
2127 rdfPort->Designation = LV2_PORT_DESIGNATION_FREEWHEELING;
2128 else if (std::strcmp(designation, LV2_CORE__latency) == 0)
2129 rdfPort->Designation = LV2_PORT_DESIGNATION_LATENCY;
2130 else if (std::strcmp(designation, LV2_PARAMETERS__sampleRate) == 0)
2131 rdfPort->Designation = LV2_PORT_DESIGNATION_SAMPLE_RATE;
2132 else if (std::strcmp(designation, LV2_TIME__bar) == 0)
2133 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BAR;
2134 else if (std::strcmp(designation, LV2_TIME__barBeat) == 0)
2135 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BAR_BEAT;
2136 else if (std::strcmp(designation, LV2_TIME__beat) == 0)
2137 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEAT;
2138 else if (std::strcmp(designation, LV2_TIME__beatUnit) == 0)
2139 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEAT_UNIT;
2140 else if (std::strcmp(designation, LV2_TIME__beatsPerBar) == 0)
2141 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEATS_PER_BAR;
2142 else if (std::strcmp(designation, LV2_TIME__beatsPerMinute) == 0)
2143 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_BEATS_PER_MINUTE;
2144 else if (std::strcmp(designation, LV2_TIME__frame) == 0)
2145 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_FRAME;
2146 else if (std::strcmp(designation, LV2_TIME__framesPerSecond) == 0)
2147 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_FRAMES_PER_SECOND;
2148 else if (std::strcmp(designation, LV2_TIME__speed) == 0)
2149 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_SPEED;
2150 else if (std::strcmp(designation, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat) == 0)
2151 rdfPort->Designation = LV2_PORT_DESIGNATION_TIME_TICKS_PER_BEAT;
2152 else if (std::strncmp(designation, LV2_PARAMETERS_PREFIX, std::strlen(LV2_PARAMETERS_PREFIX)) == 0)
2153 pass();
2154 else if (std::strncmp(designation, LV2_PORT_GROUPS_PREFIX, std::strlen(LV2_PORT_GROUPS_PREFIX)) == 0)
2155 pass();
2156 else
2157 carla_stderr("lv2_rdf_new(\"%s\") - got unknown port designation '%s'", uri, designation);
2158 }
2159 lilv_node_free(designationNode);
2160 }
2161 }
2162
2163 // --------------------------------------------------------------------------------------------------------
2164 // Set Port MIDI Map
2165
2166 if (LilvNode* const bindingNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.midi_binding.me))
2167 {
2168 if (lilv_node_is_string(bindingNode))
2169 {
2170 if (const char* const bindingAsString = lilv_node_as_string(bindingNode))
2171 {
2172 if (std::strncmp(bindingAsString, "B0", 2) == 0 && std::strlen(bindingAsString) == 6)
2173 {
2174 const char binding[3] = { bindingAsString[2], bindingAsString[3], '\0' };
2175 const long number = std::strtol(binding, nullptr, 16);
2176
2177 if (number >= 0 && number <= 0xff)
2178 {
2179 rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_CC;
2180 rdfPort->MidiMap.Number = static_cast<uint32_t>(number);
2181 }
2182 }
2183 }
2184 }
2185 else
2186 {
2187 if (lilv_node_is_blank(bindingNode))
2188 {
2189 Lilv::Nodes ctrlNumNodes(lv2World.find_nodes(bindingNode, lv2World.midi_ctlrNumber, nullptr));
2190
2191 if (ctrlNumNodes.size() == 1)
2192 {
2193 const int midiCC = ctrlNumNodes.get_first().as_int();
2194
2195 if (midiCC >= 0 && midiCC <= 0xff)
2196 {
2197 rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_CC;
2198 rdfPort->MidiMap.Number = static_cast<uint32_t>(midiCC);
2199 }
2200 }
2201
2202 lilv_nodes_free(const_cast<LilvNodes*>(ctrlNumNodes.me));
2203 }
2204 }
2205
2206 lilv_node_free(bindingNode);
2207 }
2208 else if (LilvNode* const midiMapNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.mm_defaultControl.me))
2209 {
2210 if (lilv_node_is_blank(midiMapNode))
2211 {
2212 Lilv::Nodes midiMapTypeNodes(lv2World.find_nodes(midiMapNode, lv2World.mm_controlType, nullptr));
2213 Lilv::Nodes midiMapNumberNodes(lv2World.find_nodes(midiMapNode, lv2World.mm_controlNumber, nullptr));
2214
2215 if (midiMapTypeNodes.size() == 1 && midiMapNumberNodes.size() == 1)
2216 {
2217 if (const char* const midiMapType = midiMapTypeNodes.get_first().as_string())
2218 {
2219 /**/ if (std::strcmp(midiMapType, LV2_MIDI_Map__CC) == 0)
2220 rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_CC;
2221 else if (std::strcmp(midiMapType, LV2_MIDI_Map__NRPN) == 0)
2222 rdfPort->MidiMap.Type = LV2_PORT_MIDI_MAP_NRPN;
2223 else
2224 carla_stderr("lv2_rdf_new(\"%s\") - got unknown port Midi-Map type '%s'", uri, midiMapType);
2225
2226 rdfPort->MidiMap.Number = static_cast<uint32_t>(midiMapNumberNodes.get_first().as_int());
2227 }
2228 }
2229
2230 lilv_nodes_free(const_cast<LilvNodes*>(midiMapTypeNodes.me));
2231 lilv_nodes_free(const_cast<LilvNodes*>(midiMapNumberNodes.me));
2232 }
2233
2234 lilv_node_free(midiMapNode);
2235 }
2236
2237 // --------------------------------------------------------------------------------------------------------
2238 // Set Port Points
2239 {
2240 if (LilvNode* const defNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.value_default.me))
2241 {
2242 rdfPort->Points.Hints |= LV2_PORT_POINT_DEFAULT;
2243 rdfPort->Points.Default = lilv_node_as_float(defNode);
2244 lilv_node_free(defNode);
2245 }
2246
2247 if (LilvNode* const minNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.value_minimum.me))
2248 {
2249 rdfPort->Points.Hints |= LV2_PORT_POINT_MINIMUM;
2250 rdfPort->Points.Minimum = lilv_node_as_float(minNode);
2251 lilv_node_free(minNode);
2252 }
2253
2254 if (LilvNode* const maxNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.value_maximum.me))
2255 {
2256 rdfPort->Points.Hints |= LV2_PORT_POINT_MAXIMUM;
2257 rdfPort->Points.Maximum = lilv_node_as_float(maxNode);
2258 lilv_node_free(maxNode);
2259 }
2260 }
2261
2262 // --------------------------------------------------------------------------------------------------------
2263 // Set Port Unit
2264 {
2265 if (LilvNode* const unitUnitNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.unit_unit.me))
2266 {
2267 if (lilv_node_is_uri(unitUnitNode))
2268 {
2269 if (const char* const unitUnit = lilv_node_as_uri(unitUnitNode))
2270 {
2271 rdfPort->Unit.Hints |= LV2_PORT_UNIT_UNIT;
2272
2273 /**/ if (std::strcmp(unitUnit, LV2_UNITS__bar) == 0)
2274 rdfPort->Unit.Unit = LV2_PORT_UNIT_BAR;
2275 else if (std::strcmp(unitUnit, LV2_UNITS__beat) == 0)
2276 rdfPort->Unit.Unit = LV2_PORT_UNIT_BEAT;
2277 else if (std::strcmp(unitUnit, LV2_UNITS__bpm) == 0)
2278 rdfPort->Unit.Unit = LV2_PORT_UNIT_BPM;
2279 else if (std::strcmp(unitUnit, LV2_UNITS__cent) == 0)
2280 rdfPort->Unit.Unit = LV2_PORT_UNIT_CENT;
2281 else if (std::strcmp(unitUnit, LV2_UNITS__cm) == 0)
2282 rdfPort->Unit.Unit = LV2_PORT_UNIT_CM;
2283 else if (std::strcmp(unitUnit, LV2_UNITS__coef) == 0)
2284 rdfPort->Unit.Unit = LV2_PORT_UNIT_COEF;
2285 else if (std::strcmp(unitUnit, LV2_UNITS__db) == 0)
2286 rdfPort->Unit.Unit = LV2_PORT_UNIT_DB;
2287 else if (std::strcmp(unitUnit, LV2_UNITS__degree) == 0)
2288 rdfPort->Unit.Unit = LV2_PORT_UNIT_DEGREE;
2289 else if (std::strcmp(unitUnit, LV2_UNITS__frame) == 0)
2290 rdfPort->Unit.Unit = LV2_PORT_UNIT_FRAME;
2291 else if (std::strcmp(unitUnit, LV2_UNITS__hz) == 0)
2292 rdfPort->Unit.Unit = LV2_PORT_UNIT_HZ;
2293 else if (std::strcmp(unitUnit, LV2_UNITS__inch) == 0)
2294 rdfPort->Unit.Unit = LV2_PORT_UNIT_INCH;
2295 else if (std::strcmp(unitUnit, LV2_UNITS__khz) == 0)
2296 rdfPort->Unit.Unit = LV2_PORT_UNIT_KHZ;
2297 else if (std::strcmp(unitUnit, LV2_UNITS__km) == 0)
2298 rdfPort->Unit.Unit = LV2_PORT_UNIT_KM;
2299 else if (std::strcmp(unitUnit, LV2_UNITS__m) == 0)
2300 rdfPort->Unit.Unit = LV2_PORT_UNIT_M;
2301 else if (std::strcmp(unitUnit, LV2_UNITS__mhz) == 0)
2302 rdfPort->Unit.Unit = LV2_PORT_UNIT_MHZ;
2303 else if (std::strcmp(unitUnit, LV2_UNITS__midiNote) == 0)
2304 rdfPort->Unit.Unit = LV2_PORT_UNIT_MIDINOTE;
2305 else if (std::strcmp(unitUnit, LV2_UNITS__mile) == 0)
2306 rdfPort->Unit.Unit = LV2_PORT_UNIT_MILE;
2307 else if (std::strcmp(unitUnit, LV2_UNITS__min) == 0)
2308 rdfPort->Unit.Unit = LV2_PORT_UNIT_MIN;
2309 else if (std::strcmp(unitUnit, LV2_UNITS__mm) == 0)
2310 rdfPort->Unit.Unit = LV2_PORT_UNIT_MM;
2311 else if (std::strcmp(unitUnit, LV2_UNITS__ms) == 0)
2312 rdfPort->Unit.Unit = LV2_PORT_UNIT_MS;
2313 else if (std::strcmp(unitUnit, LV2_UNITS__oct) == 0)
2314 rdfPort->Unit.Unit = LV2_PORT_UNIT_OCT;
2315 else if (std::strcmp(unitUnit, LV2_UNITS__pc) == 0)
2316 rdfPort->Unit.Unit = LV2_PORT_UNIT_PC;
2317 else if (std::strcmp(unitUnit, LV2_UNITS__s) == 0)
2318 rdfPort->Unit.Unit = LV2_PORT_UNIT_S;
2319 else if (std::strcmp(unitUnit, LV2_UNITS__semitone12TET) == 0)
2320 rdfPort->Unit.Unit = LV2_PORT_UNIT_SEMITONE;
2321 else if (std::strcmp(unitUnit, "http://moddevices.com/ns/mod#volts") == 0)
2322 rdfPort->Unit.Unit = LV2_PORT_UNIT_VOLTS;
2323 else
2324 carla_stderr("lv2_rdf_new(\"%s\") - got unknown unit '%s'", uri, unitUnit);
2325 }
2326 }
2327
2328 if (LilvNode* const unitNameNode = lilv_world_get(lv2World.me, unitUnitNode, lv2World.unit_name.me, nullptr))
2329 {
2330 if (const char* const unitName = lilv_node_as_string(unitNameNode))
2331 {
2332 rdfPort->Unit.Hints |= LV2_PORT_UNIT_NAME;
2333 rdfPort->Unit.Name = carla_strdup(unitName);
2334 }
2335 lilv_node_free(unitNameNode);
2336 }
2337
2338 if (LilvNode* const unitRenderNode = lilv_world_get(lv2World.me, unitUnitNode, lv2World.unit_render.me, nullptr))
2339 {
2340 if (const char* const unitRender = lilv_node_as_string(unitRenderNode))
2341 {
2342 rdfPort->Unit.Hints |= LV2_PORT_UNIT_RENDER;
2343 rdfPort->Unit.Render = carla_strdup(unitRender);
2344 }
2345 lilv_node_free(unitRenderNode);
2346 }
2347
2348 if (LilvNode* const unitSymbolNode = lilv_world_get(lv2World.me, unitUnitNode, lv2World.unit_symbol.me, nullptr))
2349 {
2350 if (const char* const unitSymbol = lilv_node_as_string(unitSymbolNode))
2351 {
2352 rdfPort->Unit.Hints |= LV2_PORT_UNIT_SYMBOL;
2353 rdfPort->Unit.Symbol = carla_strdup(unitSymbol);
2354 }
2355 lilv_node_free(unitSymbolNode);
2356 }
2357
2358 lilv_node_free(unitUnitNode);
2359 }
2360 }
2361
2362 // --------------------------------------------------------------------------------------------------------
2363 // Set Port Minimum Size
2364 {
2365 if (LilvNode* const minimumSizeNode = lilv_port_get(lilvPort.parent, lilvPort.me, lv2World.rz_minSize.me))
2366 {
2367 const int minimumSize(lilv_node_as_int(minimumSizeNode));
2368
2369 if (minimumSize > 0)
2370 rdfPort->MinimumSize = static_cast<uint32_t>(minimumSize);
2371 else
2372 carla_safe_assert_int("minimumSize > 0", __FILE__, __LINE__, minimumSize);
2373
2374 lilv_node_free(minimumSizeNode);
2375 }
2376 }
2377
2378 // --------------------------------------------------------------------------------------------------------
2379 // Set Port Scale Points
2380 {
2381 Lilv::ScalePoints lilvScalePoints(lilvPort.get_scale_points());
2382
2383 if (const uint numScalePoints = lilvScalePoints.size())
2384 {
2385 rdfPort->ScalePoints = new LV2_RDF_PortScalePoint[numScalePoints];
2386
2387 // get all scalepoints and sort them by value
2388 LilvScalePointMap sortedpoints;
2389
2390 LILV_FOREACH(scale_points, it, lilvScalePoints)
2391 {
2392 Lilv::ScalePoint lilvScalePoint(lilvScalePoints.get(it));
2393
2394 CARLA_SAFE_ASSERT_CONTINUE(lilvScalePoint.get_label() != nullptr);
2395
2396 if (const LilvNode* const valuenode = lilvScalePoint.get_value())
2397 {
2398 const double valueid = lilv_node_as_float(valuenode);
2399 sortedpoints[valueid] = lilvScalePoint.me;
2400 }
2401 }
2402
2403 // now safe to store, sorted by using std::map
2404 uint numUsed = 0;
2405 for (LilvScalePointMap::iterator it=sortedpoints.begin(), end=sortedpoints.end(); it != end; ++it)
2406 {
2407 CARLA_SAFE_ASSERT_BREAK(numUsed < numScalePoints);
2408 LV2_RDF_PortScalePoint* const rdfScalePoint(&rdfPort->ScalePoints[numUsed++]);
2409
2410 const LilvScalePoint* const scalepoint = it->second;
2411
2412 const LilvNode* const xlabel = lilv_scale_point_get_label(scalepoint);
2413 const LilvNode* const xvalue = lilv_scale_point_get_value(scalepoint);
2414
2415 rdfScalePoint->Label = carla_strdup(lilv_node_as_string(xlabel));
2416 rdfScalePoint->Value = lilv_node_as_float(xvalue);
2417 }
2418
2419 rdfPort->ScalePointCount = numUsed;
2420 }
2421
2422 lilv_nodes_free(const_cast<LilvNodes*>(lilvScalePoints.me));
2423 }
2424 }
2425 }
2426
2427 // ----------------------------------------------------------------------------------------------------------------
2428 // Set Plugin Parameters
2429 {
2430 std::map<std::string, LV2_RDF_Parameter> parameters;
2431 Lilv::Nodes patchReadableNodes(lilvPlugin.get_value(lv2World.patch_readable));
2432 Lilv::Nodes patchWritableNodes(lilvPlugin.get_value(lv2World.patch_writable));
2433
2434 if (const uint numParameters = patchWritableNodes.size())
2435 {
2436 uint numUsed = 0;
2437 LILV_FOREACH(nodes, it, patchWritableNodes)
2438 {
2439 CARLA_SAFE_ASSERT_BREAK(numUsed < numParameters);
2440
2441 Lilv::Node patchWritableNode(patchWritableNodes.get(it));
2442
2443 if (LilvNode* const typeNode = lilv_world_get(lv2World.me, patchWritableNode,
2444 lv2World.rdf_type.me, nullptr))
2445 {
2446 const char* const type = lilv_node_as_uri(typeNode);
2447
2448 if (std::strcmp(type, LV2_CORE__Parameter) != 0)
2449 {
2450 lilv_node_free(typeNode);
2451 continue;
2452 }
2453
2454 lilv_node_free(typeNode);
2455 }
2456 else
2457 {
2458 continue;
2459 }
2460
2461 CARLA_SAFE_ASSERT_CONTINUE(patchWritableNode.is_uri());
2462
2463 ++numUsed;
2464 LV2_RDF_Parameter rdfParam;
2465 rdfParam.URI = carla_strdup(patchWritableNode.as_uri());
2466 rdfParam.Flags = LV2_PARAMETER_FLAG_INPUT;
2467
2468 if (patchReadableNodes.contains(patchWritableNode))
2469 rdfParam.Flags |= LV2_PARAMETER_FLAG_OUTPUT;
2470
2471 // ----------------------------------------------------------------------------------------------------
2472 // Set Basics
2473
2474 if (LilvNode* const rangeNode = lilv_world_get(lv2World.me, patchWritableNode,
2475 lv2World.rdfs_range.me, nullptr))
2476 {
2477 const char* const rangeURI = lilv_node_as_string(rangeNode);
2478
2479 /**/ if (std::strcmp(rangeURI, LV2_ATOM__Bool) == 0)
2480 rdfParam.Type = LV2_PARAMETER_TYPE_BOOL;
2481 else if (std::strcmp(rangeURI, LV2_ATOM__Int) == 0)
2482 rdfParam.Type = LV2_PARAMETER_TYPE_INT;
2483 else if (std::strcmp(rangeURI, LV2_ATOM__Long) == 0)
2484 rdfParam.Type = LV2_PARAMETER_TYPE_LONG;
2485 else if (std::strcmp(rangeURI, LV2_ATOM__Float) == 0)
2486 rdfParam.Type = LV2_PARAMETER_TYPE_FLOAT;
2487 else if (std::strcmp(rangeURI, LV2_ATOM__Double) == 0)
2488 rdfParam.Type = LV2_PARAMETER_TYPE_DOUBLE;
2489 else if (std::strcmp(rangeURI, LV2_ATOM__Path) == 0)
2490 rdfParam.Type = LV2_PARAMETER_TYPE_PATH;
2491 else if (std::strcmp(rangeURI, LV2_ATOM__String) == 0)
2492 rdfParam.Type = LV2_PARAMETER_TYPE_STRING;
2493 else
2494 carla_stderr("lv2_rdf_new(\"%s\") - got unknown parameter type '%s'", uri, rangeURI);
2495
2496 lilv_node_free(rangeNode);
2497 }
2498
2499 if (LilvNode* const labelNode = lilv_world_get(lv2World.me, patchWritableNode,
2500 lv2World.rdfs_label.me, nullptr))
2501 {
2502 rdfParam.Label = carla_strdup(lilv_node_as_string(labelNode));
2503 lilv_node_free(labelNode);
2504 }
2505
2506 if (LilvNode* const commentNode = lilv_world_get(lv2World.me, patchWritableNode,
2507 lv2World.rdfs_comment.me, nullptr))
2508 {
2509 rdfParam.Comment = carla_strdup_safe(lilv_node_as_string(commentNode));
2510 lilv_node_free(commentNode);
2511 }
2512
2513 if (LilvNode* const groupNode = lilv_world_get(lv2World.me, patchWritableNode,
2514 lv2World.pg_group.me, nullptr))
2515 {
2516 rdfParam.GroupURI = carla_strdup_safe(lilv_node_as_uri(groupNode));
2517
2518 if (portGroupURIs.appendUnique(rdfParam.GroupURI))
2519 portGroupNodes.append(groupNode);
2520 else
2521 lilv_node_free(groupNode);
2522 }
2523
2524 // ----------------------------------------------------------------------------------------------------
2525 // Set Port MIDI Map
2526
2527 if (LilvNode* const bindingNode = lilv_world_get(lv2World.me, patchWritableNode,
2528 lv2World.midi_binding.me, nullptr))
2529 {
2530 if (const char* const bindingAsString = lilv_node_as_string(bindingNode))
2531 {
2532 if (std::strncmp(bindingAsString, "B0", 2) == 0 && std::strlen(bindingAsString) == 6)
2533 {
2534 const char binding[3] = { bindingAsString[2], bindingAsString[3], '\0' };
2535 const long number = std::strtol(binding, nullptr, 16);
2536
2537 if (number >= 0 && number <= 0xff)
2538 {
2539 rdfParam.MidiMap.Type = LV2_PORT_MIDI_MAP_CC;
2540 rdfParam.MidiMap.Number = static_cast<uint32_t>(number);
2541 }
2542 }
2543 }
2544
2545 lilv_node_free(bindingNode);
2546 }
2547
2548 // ----------------------------------------------------------------------------------------------------
2549 // Set Port Points
2550
2551 if (LilvNode* const defNode = lilv_world_get(lv2World.me, patchWritableNode,
2552 lv2World.value_default.me, nullptr))
2553 {
2554 rdfParam.Points.Hints |= LV2_PORT_POINT_DEFAULT;
2555 rdfParam.Points.Default = lilv_node_as_float(defNode);
2556 lilv_node_free(defNode);
2557 }
2558
2559 if (LilvNode* const minNode = lilv_world_get(lv2World.me, patchWritableNode,
2560 lv2World.value_minimum.me, nullptr))
2561 {
2562 rdfParam.Points.Hints |= LV2_PORT_POINT_MINIMUM;
2563 rdfParam.Points.Minimum = lilv_node_as_float(minNode);
2564 lilv_node_free(minNode);
2565 }
2566
2567 if (LilvNode* const maxNode = lilv_world_get(lv2World.me, patchWritableNode,
2568 lv2World.value_maximum.me, nullptr))
2569 {
2570 rdfParam.Points.Hints |= LV2_PORT_POINT_MAXIMUM;
2571 rdfParam.Points.Maximum = lilv_node_as_float(maxNode);
2572 lilv_node_free(maxNode);
2573 }
2574
2575 // ----------------------------------------------------------------------------------------------------
2576 // Set Port Unit
2577
2578 if (LilvNode* const unitUnitNode = lilv_world_get(lv2World.me, patchWritableNode,
2579 lv2World.unit_unit.me, nullptr))
2580 {
2581 if (lilv_node_is_uri(unitUnitNode))
2582 {
2583 if (const char* const unitUnit = lilv_node_as_uri(unitUnitNode))
2584 {
2585 rdfParam.Unit.Hints |= LV2_PORT_UNIT_UNIT;
2586
2587 /**/ if (std::strcmp(unitUnit, LV2_UNITS__bar) == 0)
2588 rdfParam.Unit.Unit = LV2_PORT_UNIT_BAR;
2589 else if (std::strcmp(unitUnit, LV2_UNITS__beat) == 0)
2590 rdfParam.Unit.Unit = LV2_PORT_UNIT_BEAT;
2591 else if (std::strcmp(unitUnit, LV2_UNITS__bpm) == 0)
2592 rdfParam.Unit.Unit = LV2_PORT_UNIT_BPM;
2593 else if (std::strcmp(unitUnit, LV2_UNITS__cent) == 0)
2594 rdfParam.Unit.Unit = LV2_PORT_UNIT_CENT;
2595 else if (std::strcmp(unitUnit, LV2_UNITS__cm) == 0)
2596 rdfParam.Unit.Unit = LV2_PORT_UNIT_CM;
2597 else if (std::strcmp(unitUnit, LV2_UNITS__coef) == 0)
2598 rdfParam.Unit.Unit = LV2_PORT_UNIT_COEF;
2599 else if (std::strcmp(unitUnit, LV2_UNITS__db) == 0)
2600 rdfParam.Unit.Unit = LV2_PORT_UNIT_DB;
2601 else if (std::strcmp(unitUnit, LV2_UNITS__degree) == 0)
2602 rdfParam.Unit.Unit = LV2_PORT_UNIT_DEGREE;
2603 else if (std::strcmp(unitUnit, LV2_UNITS__frame) == 0)
2604 rdfParam.Unit.Unit = LV2_PORT_UNIT_FRAME;
2605 else if (std::strcmp(unitUnit, LV2_UNITS__hz) == 0)
2606 rdfParam.Unit.Unit = LV2_PORT_UNIT_HZ;
2607 else if (std::strcmp(unitUnit, LV2_UNITS__inch) == 0)
2608 rdfParam.Unit.Unit = LV2_PORT_UNIT_INCH;
2609 else if (std::strcmp(unitUnit, LV2_UNITS__khz) == 0)
2610 rdfParam.Unit.Unit = LV2_PORT_UNIT_KHZ;
2611 else if (std::strcmp(unitUnit, LV2_UNITS__km) == 0)
2612 rdfParam.Unit.Unit = LV2_PORT_UNIT_KM;
2613 else if (std::strcmp(unitUnit, LV2_UNITS__m) == 0)
2614 rdfParam.Unit.Unit = LV2_PORT_UNIT_M;
2615 else if (std::strcmp(unitUnit, LV2_UNITS__mhz) == 0)
2616 rdfParam.Unit.Unit = LV2_PORT_UNIT_MHZ;
2617 else if (std::strcmp(unitUnit, LV2_UNITS__midiNote) == 0)
2618 rdfParam.Unit.Unit = LV2_PORT_UNIT_MIDINOTE;
2619 else if (std::strcmp(unitUnit, LV2_UNITS__mile) == 0)
2620 rdfParam.Unit.Unit = LV2_PORT_UNIT_MILE;
2621 else if (std::strcmp(unitUnit, LV2_UNITS__min) == 0)
2622 rdfParam.Unit.Unit = LV2_PORT_UNIT_MIN;
2623 else if (std::strcmp(unitUnit, LV2_UNITS__mm) == 0)
2624 rdfParam.Unit.Unit = LV2_PORT_UNIT_MM;
2625 else if (std::strcmp(unitUnit, LV2_UNITS__ms) == 0)
2626 rdfParam.Unit.Unit = LV2_PORT_UNIT_MS;
2627 else if (std::strcmp(unitUnit, LV2_UNITS__oct) == 0)
2628 rdfParam.Unit.Unit = LV2_PORT_UNIT_OCT;
2629 else if (std::strcmp(unitUnit, LV2_UNITS__pc) == 0)
2630 rdfParam.Unit.Unit = LV2_PORT_UNIT_PC;
2631 else if (std::strcmp(unitUnit, LV2_UNITS__s) == 0)
2632 rdfParam.Unit.Unit = LV2_PORT_UNIT_S;
2633 else if (std::strcmp(unitUnit, LV2_UNITS__semitone12TET) == 0)
2634 rdfParam.Unit.Unit = LV2_PORT_UNIT_SEMITONE;
2635 else if (std::strcmp(unitUnit, "http://moddevices.com/ns/mod#volts") == 0)
2636 rdfParam.Unit.Unit = LV2_PORT_UNIT_VOLTS;
2637 else
2638 carla_stderr("lv2_rdf_new(\"%s\") - got unknown unit '%s'", uri, unitUnit);
2639 }
2640 }
2641
2642 if (LilvNode* const unitNameNode = lilv_world_get(lv2World.me, unitUnitNode,
2643 lv2World.unit_name.me, nullptr))
2644 {
2645 if (const char* const unitName = lilv_node_as_string(unitNameNode))
2646 {
2647 rdfParam.Unit.Hints |= LV2_PORT_UNIT_NAME;
2648 rdfParam.Unit.Name = carla_strdup(unitName);
2649 }
2650 lilv_node_free(unitNameNode);
2651 }
2652
2653 if (LilvNode* const unitRenderNode = lilv_world_get(lv2World.me, unitUnitNode,
2654 lv2World.unit_render.me, nullptr))
2655 {
2656 if (const char* const unitRender = lilv_node_as_string(unitRenderNode))
2657 {
2658 rdfParam.Unit.Hints |= LV2_PORT_UNIT_RENDER;
2659 rdfParam.Unit.Render = carla_strdup(unitRender);
2660 }
2661 lilv_node_free(unitRenderNode);
2662 }
2663
2664 if (LilvNode* const unitSymbolNode = lilv_world_get(lv2World.me, unitUnitNode,
2665 lv2World.unit_symbol.me, nullptr))
2666 {
2667 if (const char* const unitSymbol = lilv_node_as_string(unitSymbolNode))
2668 {
2669 rdfParam.Unit.Hints |= LV2_PORT_UNIT_SYMBOL;
2670 rdfParam.Unit.Symbol = carla_strdup(unitSymbol);
2671 }
2672 lilv_node_free(unitSymbolNode);
2673 }
2674
2675 lilv_node_free(unitUnitNode);
2676 }
2677
2678 parameters[rdfParam.URI].copyAndReplace(rdfParam);
2679 }
2680
2681 CARLA_SAFE_ASSERT_UINT2(parameters.size() == numUsed, parameters.size(), numUsed);
2682 rdfDescriptor->Parameters = new LV2_RDF_Parameter[numUsed];
2683 rdfDescriptor->ParameterCount = numUsed;
2684
2685 numUsed = 0;
2686 for (std::map<std::string, LV2_RDF_Parameter>::iterator it = parameters.begin(), end = parameters.end();
2687 it != end; ++it)
2688 {
2689 rdfDescriptor->Parameters[numUsed++].copyAndReplace(it->second);
2690 }
2691 }
2692
2693 lilv_nodes_free(const_cast<LilvNodes*>(patchReadableNodes.me));
2694 lilv_nodes_free(const_cast<LilvNodes*>(patchWritableNodes.me));
2695 }
2696
2697 // ----------------------------------------------------------------------------------------------------------------
2698 // Set Plugin Port Groups
2699
2700 if (const size_t portGroupCount = portGroupURIs.count())
2701 {
2702 rdfDescriptor->PortGroups = new LV2_RDF_PortGroup[portGroupCount];
2703
2704 uint32_t count = 0;
2705 CarlaStringList::Itenerator itu = portGroupURIs.begin2();
2706 LinkedList<LilvNode*>::Itenerator itn = portGroupNodes.begin2();
2707 for (; itu.valid() && itn.valid(); itu.next(), itn.next())
2708 {
2709 const char* const portGroupURI = itu.getValue(nullptr);
2710 CARLA_SAFE_ASSERT_CONTINUE(portGroupURI != nullptr);
2711
2712 LilvNode* const portGroupNode = itn.getValue(nullptr);
2713 CARLA_SAFE_ASSERT_CONTINUE(portGroupNode != nullptr);
2714
2715 LV2_RDF_PortGroup& portGroup(rdfDescriptor->PortGroups[count]);
2716 portGroup.URI = portGroupURI;
2717
2718 if (LilvNode* const portGroupNameNode = lilv_world_get(lv2World.me, portGroupNode,
2719 lv2World.lv2_name.me, nullptr))
2720 {
2721 portGroup.Name = carla_strdup_safe(lilv_node_as_string(portGroupNameNode));
2722 lilv_node_free(portGroupNameNode);
2723 }
2724 // some plugins use rdfs:label, spec was not clear which one to use
2725 else if (LilvNode* const portGroupLabelNode = lilv_world_get(lv2World.me, portGroupNode,
2726 lv2World.rdfs_label.me, nullptr))
2727 {
2728 portGroup.Name = carla_strdup_safe(lilv_node_as_string(portGroupLabelNode));
2729 lilv_node_free(portGroupLabelNode);
2730 }
2731
2732 if (LilvNode* const portGroupSymbolNode = lilv_world_get(lv2World.me, portGroupNode,
2733 lv2World.lv2_symbol.me, nullptr))
2734 {
2735 portGroup.Symbol = carla_strdup_safe(lilv_node_as_string(portGroupSymbolNode));
2736 lilv_node_free(portGroupSymbolNode);
2737 }
2738
2739 ++count;
2740 lilv_node_free(portGroupNode);
2741 }
2742
2743 rdfDescriptor->PortGroupCount = count;
2744 portGroupNodes.clear();
2745 }
2746
2747 // ----------------------------------------------------------------------------------------------------------------
2748 // Set Plugin Presets
2749
2750 if (loadPresets)
2751 {
2752 Lilv::Nodes presetNodes(lilvPlugin.get_related(lv2World.preset_preset));
2753
2754 if (presetNodes.size() > 0)
2755 {
2756 // create a list of preset URIs (for sorting and unique-ness)
2757 #if defined(CARLA_UTILS_USE_QT)
2758 QStringList presetListURIs;
2759
2760 LILV_FOREACH(nodes, it, presetNodes)
2761 {
2762 Lilv::Node presetNode(presetNodes.get(it));
2763
2764 QString presetURI(presetNode.as_uri());
2765
2766 if (! (presetURI.trimmed().isEmpty() || presetListURIs.contains(presetURI)))
2767 presetListURIs.append(presetURI);
2768 }
2769
2770 presetListURIs.sort();
2771
2772 rdfDescriptor->PresetCount = static_cast<uint32_t>(presetListURIs.count());
2773 #else
2774 water::StringArray presetListURIs;
2775
2776 LILV_FOREACH(nodes, it, presetNodes)
2777 {
2778 Lilv::Node presetNode(presetNodes.get(it));
2779
2780 water::String presetURI(presetNode.as_uri());
2781
2782 if (presetURI.trim().isNotEmpty())
2783 presetListURIs.addIfNotAlreadyThere(presetURI);
2784 }
2785
2786 presetListURIs.sortNatural();
2787
2788 rdfDescriptor->PresetCount = static_cast<uint32_t>(presetListURIs.size());
2789 #endif
2790
2791 // create presets with unique URIs
2792 rdfDescriptor->Presets = new LV2_RDF_Preset[rdfDescriptor->PresetCount];
2793
2794 // set preset data
2795 LILV_FOREACH(nodes, it, presetNodes)
2796 {
2797 Lilv::Node presetNode(presetNodes.get(it));
2798
2799 const char* const presetURI(presetNode.as_uri());
2800 CARLA_SAFE_ASSERT_CONTINUE(presetURI != nullptr && presetURI[0] != '\0');
2801
2802 // try to find label without loading the preset resource first
2803 Lilv::Nodes presetLabelNodes(lv2World.find_nodes(presetNode, lv2World.rdfs_label, nullptr));
2804
2805 // failed, try loading resource
2806 if (presetLabelNodes.size() == 0)
2807 {
2808 // if loading resource fails, skip this preset
2809 if (lv2World.load_resource(presetNode) == -1)
2810 continue;
2811
2812 // ok, let's try again
2813 presetLabelNodes = lv2World.find_nodes(presetNode, lv2World.rdfs_label, nullptr);
2814 }
2815
2816 if (presetLabelNodes.size() > 0)
2817 {
2818 #if defined(CARLA_UTILS_USE_QT)
2819 const int index = presetListURIs.indexOf(QString(presetURI));
2820 #else
2821 const int index = presetListURIs.indexOf(water::String(presetURI));
2822 #endif
2823 CARLA_SAFE_ASSERT_CONTINUE(index >= 0 && index < static_cast<int>(rdfDescriptor->PresetCount));
2824
2825 LV2_RDF_Preset* const rdfPreset(&rdfDescriptor->Presets[index]);
2826
2827 // ---------------------------------------------------
2828 // Set Preset Information
2829
2830 rdfPreset->URI = carla_strdup(presetURI);
2831
2832 if (const char* const label = presetLabelNodes.get_first().as_string())
2833 rdfPreset->Label = carla_strdup(label);
2834
2835 lilv_nodes_free(const_cast<LilvNodes*>(presetLabelNodes.me));
2836 }
2837 }
2838 }
2839
2840 lilv_nodes_free(const_cast<LilvNodes*>(presetNodes.me));
2841 }
2842
2843 // ----------------------------------------------------------------------------------------------------------------
2844 // Set Plugin Features
2845 {
2846 Lilv::Nodes lilvFeatureNodes(lilvPlugin.get_supported_features());
2847
2848 if (const uint numFeatures = lilvFeatureNodes.size())
2849 {
2850 Lilv::Nodes lilvFeatureNodesR(lilvPlugin.get_required_features());
2851
2852 rdfDescriptor->Features = new LV2_RDF_Feature[numFeatures];
2853
2854 uint numUsed = 0;
2855 LILV_FOREACH(nodes, it, lilvFeatureNodes)
2856 {
2857 CARLA_SAFE_ASSERT_BREAK(numUsed < numFeatures);
2858
2859 Lilv::Node lilvFeatureNode(lilvFeatureNodes.get(it));
2860 LV2_RDF_Feature* const rdfFeature(&rdfDescriptor->Features[numUsed++]);
2861
2862 rdfFeature->Required = lilvFeatureNodesR.contains(lilvFeatureNode);
2863
2864 if (const char* const featureURI = lilvFeatureNode.as_uri())
2865 rdfFeature->URI = carla_strdup(featureURI);
2866 else
2867 rdfFeature->URI = nullptr;
2868 }
2869
2870 rdfDescriptor->FeatureCount = numUsed;
2871 lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodesR.me));
2872 }
2873
2874 lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodes.me));
2875 }
2876
2877 // ----------------------------------------------------------------------------------------------------------------
2878 // Set Plugin Extensions
2879 {
2880 Lilv::Nodes lilvExtensionDataNodes(lilvPlugin.get_extension_data());
2881
2882 if (const uint numExtensions = lilvExtensionDataNodes.size())
2883 {
2884 rdfDescriptor->Extensions = new LV2_URI[numExtensions];
2885
2886 uint numUsed = 0;
2887 LILV_FOREACH(nodes, it, lilvExtensionDataNodes)
2888 {
2889 CARLA_SAFE_ASSERT_BREAK(numUsed < numExtensions);
2890
2891 Lilv::Node lilvExtensionDataNode(lilvExtensionDataNodes.get(it));
2892 LV2_URI* const rdfExtension(&rdfDescriptor->Extensions[numUsed++]);
2893
2894 if (lilvExtensionDataNode.is_uri())
2895 {
2896 if (const char* const extURI = lilvExtensionDataNode.as_uri())
2897 {
2898 *rdfExtension = carla_strdup(extURI);
2899 continue;
2900 }
2901 }
2902 *rdfExtension = nullptr;
2903 }
2904
2905 for (uint32_t x=numUsed; x < rdfDescriptor->ExtensionCount; ++x)
2906 rdfDescriptor->Extensions[x] = nullptr;
2907
2908 rdfDescriptor->ExtensionCount = numUsed;
2909 }
2910
2911 lilv_nodes_free(const_cast<LilvNodes*>(lilvExtensionDataNodes.me));
2912 }
2913
2914 // ----------------------------------------------------------------------------------------------------------------
2915 // Set Plugin UIs
2916 {
2917 #ifdef CARLA_OS_LINUX
2918 const bool hasMODGui = lilvPlugin.get_modgui_resources_directory().as_uri() != nullptr;
2919 #else
2920 const bool hasMODGui = false;
2921 #endif
2922
2923 Lilv::UIs lilvUIs(lilvPlugin.get_uis());
2924
2925 const uint numUIs = lilvUIs.size() + (hasMODGui ? 1 : 0);
2926
2927 if (numUIs > 0)
2928 {
2929 rdfDescriptor->UIs = new LV2_RDF_UI[numUIs];
2930
2931 uint numUsed = 0;
2932 LILV_FOREACH(uis, it, lilvUIs)
2933 {
2934 CARLA_SAFE_ASSERT_BREAK(numUsed < numUIs);
2935
2936 Lilv::UI lilvUI(lilvUIs.get(it));
2937 LV2_RDF_UI* const rdfUI(&rdfDescriptor->UIs[numUsed++]);
2938
2939 lv2World.load_resource(lilvUI.get_uri());
2940
2941 // ----------------------------------------------------------------------------------------------------
2942 // Set UI Type
2943
2944 /**/ if (lilvUI.is_a(lv2World.ui_gtk2))
2945 rdfUI->Type = LV2_UI_GTK2;
2946 else if (lilvUI.is_a(lv2World.ui_gtk3))
2947 rdfUI->Type = LV2_UI_GTK3;
2948 else if (lilvUI.is_a(lv2World.ui_qt4))
2949 rdfUI->Type = LV2_UI_QT4;
2950 else if (lilvUI.is_a(lv2World.ui_qt5))
2951 rdfUI->Type = LV2_UI_QT5;
2952 else if (lilvUI.is_a(lv2World.ui_cocoa))
2953 rdfUI->Type = LV2_UI_COCOA;
2954 else if (lilvUI.is_a(lv2World.ui_windows))
2955 rdfUI->Type = LV2_UI_WINDOWS;
2956 else if (lilvUI.is_a(lv2World.ui_x11))
2957 rdfUI->Type = LV2_UI_X11;
2958 else if (lilvUI.is_a(lv2World.ui_external))
2959 rdfUI->Type = LV2_UI_EXTERNAL;
2960 else if (lilvUI.is_a(lv2World.ui_externalOld))
2961 rdfUI->Type = LV2_UI_OLD_EXTERNAL;
2962 else if (lilvUI.is_a(lv2World.ui))
2963 rdfUI->Type = LV2_UI_NONE;
2964 else
2965 carla_stderr("lv2_rdf_new(\"%s\") - UI '%s' is of unknown type", uri, lilvUI.get_uri().as_uri());
2966
2967 // ----------------------------------------------------------------------------------------------------
2968 // Set UI Information
2969 {
2970 if (const char* const uiURI = lilvUI.get_uri().as_uri())
2971 rdfUI->URI = carla_strdup(uiURI);
2972
2973 if (const char* const uiBinary = lilvUI.get_binary_uri().as_string())
2974 rdfUI->Binary = carla_strdup_free(lilv_file_uri_parse(uiBinary, nullptr));
2975
2976 if (const char* const uiBundle = lilvUI.get_bundle_uri().as_string())
2977 rdfUI->Bundle = carla_strdup_free(lilv_file_uri_parse(uiBundle, nullptr));
2978 }
2979
2980 // ----------------------------------------------------------------------------------------------------
2981 // Set UI Features
2982 {
2983 Lilv::Nodes lilvFeatureNodes(lilvUI.get_supported_features());
2984
2985 if (const uint numFeatures = lilvFeatureNodes.size())
2986 {
2987 Lilv::Nodes lilvFeatureNodesR(lilvUI.get_required_features());
2988
2989 rdfUI->Features = new LV2_RDF_Feature[numFeatures];
2990
2991 uint numUsed2 = 0;
2992 LILV_FOREACH(nodes, it2, lilvFeatureNodes)
2993 {
2994 CARLA_SAFE_ASSERT_UINT2_BREAK(numUsed2 < numFeatures, numUsed2, numFeatures);
2995
2996 Lilv::Node lilvFeatureNode(lilvFeatureNodes.get(it2));
2997 LV2_RDF_Feature* const rdfFeature(&rdfUI->Features[numUsed2++]);
2998
2999 rdfFeature->Required = lilvFeatureNodesR.contains(lilvFeatureNode);
3000
3001 if (const char* const featureURI = lilvFeatureNode.as_uri())
3002 rdfFeature->URI = carla_strdup(featureURI);
3003 else
3004 rdfFeature->URI = nullptr;
3005 }
3006
3007 rdfUI->FeatureCount = numUsed2;
3008 lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodesR.me));
3009 }
3010
3011 lilv_nodes_free(const_cast<LilvNodes*>(lilvFeatureNodes.me));
3012 }
3013
3014 // ----------------------------------------------------------------------------------------------------
3015 // Set UI Extensions
3016 {
3017 Lilv::Nodes lilvExtensionDataNodes(lilvUI.get_extension_data());
3018
3019 if (const uint numExtensions = lilvExtensionDataNodes.size())
3020 {
3021 rdfUI->Extensions = new LV2_URI[numExtensions];
3022
3023 uint numUsed2 = 0;
3024 LILV_FOREACH(nodes, it2, lilvExtensionDataNodes)
3025 {
3026 CARLA_SAFE_ASSERT_UINT2_BREAK(numUsed2 < numExtensions, numUsed2, numExtensions);
3027
3028 Lilv::Node lilvExtensionDataNode(lilvExtensionDataNodes.get(it2));
3029 LV2_URI* const rdfExtension(&rdfUI->Extensions[numUsed2++]);
3030
3031 if (lilvExtensionDataNode.is_uri())
3032 {
3033 if (const char* const extURI = lilvExtensionDataNode.as_uri())
3034 {
3035 *rdfExtension = carla_strdup(extURI);
3036 continue;
3037 }
3038 }
3039 *rdfExtension = nullptr;
3040 }
3041
3042 for (uint x2=numUsed2; x2 < rdfUI->ExtensionCount; ++x2)
3043 rdfUI->Extensions[x2] = nullptr;
3044
3045 rdfUI->ExtensionCount = numUsed2;
3046 }
3047
3048 lilv_nodes_free(const_cast<LilvNodes*>(lilvExtensionDataNodes.me));
3049 }
3050
3051 // ----------------------------------------------------------------------------------------------------
3052 // Set UI Port Notifications
3053 {
3054 Lilv::Nodes portNotifNodes(lv2World.find_nodes(lilvUI.get_uri(), lv2World.ui_portNotif.me, nullptr));
3055
3056 if (const uint portNotifCount = portNotifNodes.size())
3057 {
3058 rdfUI->PortNotificationCount = portNotifCount;
3059 rdfUI->PortNotifications = new LV2_RDF_UI_PortNotification[portNotifCount];
3060
3061 uint numUsed2 = 0;
3062 LILV_FOREACH(nodes, it2, portNotifNodes)
3063 {
3064 CARLA_SAFE_ASSERT_UINT2_BREAK(numUsed2 < portNotifCount, numUsed2, portNotifCount);
3065
3066 Lilv::Node portNotifNode(portNotifNodes.get(it2));
3067 LV2_RDF_UI_PortNotification* const rdfPortNotif(&rdfUI->PortNotifications[numUsed2++]);
3068
3069 LilvNode* const protocolNode = lilv_world_get(lv2World.me, portNotifNode,
3070 lv2World.ui_protocol.me, nullptr);
3071
3072 if (protocolNode != nullptr)
3073 {
3074 CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_uri(protocolNode));
3075
3076 const char* const protocol = lilv_node_as_uri(protocolNode);
3077 CARLA_SAFE_ASSERT_CONTINUE(protocol != nullptr && protocol[0] != '\0');
3078
3079 /**/ if (std::strcmp(protocol, LV2_UI__floatProtocol) == 0)
3080 rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_FLOAT;
3081 else if (std::strcmp(protocol, LV2_UI__peakProtocol) == 0)
3082 rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_PEAK;
3083 }
3084 else
3085 {
3086 rdfPortNotif->Protocol = LV2_UI_PORT_PROTOCOL_FLOAT;
3087 }
3088
3089 /**/ if (LilvNode* const symbolNode = lilv_world_get(lv2World.me, portNotifNode,
3090 lv2World.symbol.me, nullptr))
3091 {
3092 CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_string(symbolNode));
3093
3094 const char* const symbol = lilv_node_as_string(symbolNode);
3095 CARLA_SAFE_ASSERT_CONTINUE(symbol != nullptr && symbol[0] != '\0');
3096
3097 rdfPortNotif->Symbol = carla_strdup(symbol);
3098
3099 lilv_node_free(symbolNode);
3100 }
3101 else if (LilvNode* const indexNode = lilv_world_get(lv2World.me, portNotifNode,
3102 lv2World.ui_portIndex.me, nullptr))
3103 {
3104 CARLA_SAFE_ASSERT_CONTINUE(lilv_node_is_int(indexNode));
3105
3106 const int index = lilv_node_as_int(indexNode);
3107 CARLA_SAFE_ASSERT_CONTINUE(index >= 0);
3108
3109 rdfPortNotif->Index = static_cast<uint32_t>(index);
3110
3111 lilv_node_free(indexNode);
3112 }
3113
3114 lilv_node_free(protocolNode);
3115 }
3116 }
3117
3118 lilv_nodes_free(const_cast<LilvNodes*>(portNotifNodes.me));
3119 }
3120 }
3121
3122 for (; hasMODGui;)
3123 {
3124 CARLA_SAFE_ASSERT_BREAK(numUsed == numUIs-1);
3125
3126 LV2_RDF_UI* const rdfUI(&rdfDescriptor->UIs[numUsed++]);
3127
3128 // -------------------------------------------------------
3129 // Set UI Type
3130
3131 rdfUI->Type = LV2_UI_MOD;
3132
3133 // -------------------------------------------------------
3134 // Set UI Information
3135
3136 if (const char* const resDir = lilvPlugin.get_modgui_resources_directory().as_uri())
3137 rdfUI->URI = carla_strdup_free(lilv_file_uri_parse(resDir, nullptr));
3138
3139 if (rdfDescriptor->Bundle != nullptr)
3140 rdfUI->Bundle = carla_strdup(rdfDescriptor->Bundle);
3141
3142 break;
3143 }
3144
3145 rdfDescriptor->UICount = numUsed;
3146 }
3147
3148 lilv_nodes_free(const_cast<LilvNodes*>(lilvUIs.me));
3149 }
3150
3151 return rdfDescriptor;
3152 }
3153
3154 // --------------------------------------------------------------------------------------------------------------------
3155 // Check if we support a plugin port
3156
3157 static inline
3158 bool is_lv2_port_supported(const LV2_Property types) noexcept
3159 {
3160 if (LV2_IS_PORT_CONTROL(types))
3161 return true;
3162 if (LV2_IS_PORT_AUDIO(types))
3163 return true;
3164 if (LV2_IS_PORT_CV(types))
3165 return true;
3166 if (LV2_IS_PORT_ATOM_SEQUENCE(types))
3167 return true;
3168 if (LV2_IS_PORT_EVENT(types))
3169 return true;
3170 if (LV2_IS_PORT_MIDI_LL(types))
3171 return true;
3172 return false;
3173 }
3174
3175 // --------------------------------------------------------------------------------------------------------------------
3176 // Check if we support a plugin feature
3177
3178 static inline
3179 bool is_lv2_feature_supported(const LV2_URI uri) noexcept
3180 {
3181 CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', false);
3182
3183 if (std::strcmp(uri, LV2_BUF_SIZE__boundedBlockLength) == 0)
3184 return true;
3185 if (std::strcmp(uri, LV2_BUF_SIZE__fixedBlockLength) == 0)
3186 return true;
3187 if (std::strcmp(uri, LV2_BUF_SIZE__powerOf2BlockLength) == 0)
3188 return true;
3189 if (std::strcmp(uri, LV2_CONTROL_INPUT_PORT_CHANGE_REQUEST_URI) == 0)
3190 return true;
3191 if (std::strcmp(uri, LV2_CORE__hardRTCapable) == 0)
3192 return true;
3193 if (std::strcmp(uri, LV2_CORE__inPlaceBroken) == 0)
3194 return true;
3195 if (std::strcmp(uri, LV2_CORE__isLive) == 0)
3196 return true;
3197 if (std::strcmp(uri, LV2_EVENT_URI) == 0)
3198 return true;
3199 if (std::strcmp(uri, LV2_INLINEDISPLAY__queue_draw) == 0)
3200 return true;
3201 if (std::strcmp(uri, LV2_LOG__log) == 0)
3202 return true;
3203 if (std::strcmp(uri, LV2_OPTIONS__options) == 0)
3204 return true;
3205 if (std::strcmp(uri, LV2_PROGRAMS__Host) == 0)
3206 return true;
3207 if (std::strcmp(uri, LV2_RESIZE_PORT__resize) == 0)
3208 return true;
3209 if (std::strcmp(uri, LV2_RTSAFE_MEMORY_POOL__Pool) == 0)
3210 return true;
3211 if (std::strcmp(uri, LV2_RTSAFE_MEMORY_POOL_DEPRECATED_URI) == 0)
3212 return true;
3213 if (std::strcmp(uri, LV2_STATE__freePath) == 0)
3214 return true;
3215 if (std::strcmp(uri, LV2_STATE__loadDefaultState) == 0)
3216 return true;
3217 if (std::strcmp(uri, LV2_STATE__makePath) == 0)
3218 return true;
3219 if (std::strcmp(uri, LV2_STATE__mapPath) == 0)
3220 return true;
3221 if (std::strcmp(uri, LV2_STATE__threadSafeRestore) == 0)
3222 return true;
3223 if (std::strcmp(uri, LV2_PORT_PROPS__supportsStrictBounds) == 0)
3224 return true;
3225 if (std::strcmp(uri, LV2_URI_MAP_URI) == 0)
3226 return true;
3227 if (std::strcmp(uri, LV2_URID__map) == 0)
3228 return true;
3229 if (std::strcmp(uri, LV2_URID__unmap) == 0)
3230 return true;
3231 if (std::strcmp(uri, LV2_WORKER__schedule) == 0)
3232 return true;
3233 return false;
3234 }
3235
3236 // --------------------------------------------------------------------------------------------------------------------
3237 // Check if we support a plugin or UI feature
3238
3239 static inline
3240 bool is_lv2_ui_feature_supported(const LV2_URI uri) noexcept
3241 {
3242 CARLA_SAFE_ASSERT_RETURN(uri != nullptr && uri[0] != '\0', false);
3243
3244 if (is_lv2_feature_supported(uri))
3245 return true;
3246 #ifndef BUILD_BRIDGE_UI
3247 if (std::strcmp(uri, LV2_DATA_ACCESS_URI) == 0)
3248 return true;
3249 if (std::strcmp(uri, LV2_INSTANCE_ACCESS_URI) == 0)
3250 return true;
3251 #endif
3252 if (std::strcmp(uri, LV2_UI__fixedSize) == 0)
3253 return true;
3254 if (std::strcmp(uri, LV2_UI__idleInterface) == 0)
3255 return true;
3256 if (std::strcmp(uri, LV2_UI__makeResident) == 0)
3257 return true;
3258 if (std::strcmp(uri, LV2_UI__makeSONameResident) == 0)
3259 return true;
3260 if (std::strcmp(uri, LV2_UI__noUserResize) == 0)
3261 return true;
3262 if (std::strcmp(uri, LV2_UI__parent) == 0)
3263 return true;
3264 if (std::strcmp(uri, LV2_UI__portMap) == 0)
3265 return true;
3266 if (std::strcmp(uri, LV2_UI__portSubscribe) == 0)
3267 return true;
3268 if (std::strcmp(uri, LV2_UI__requestValue) == 0)
3269 return true;
3270 if (std::strcmp(uri, LV2_UI__resize) == 0)
3271 return true;
3272 if (std::strcmp(uri, LV2_UI__touch) == 0)
3273 return true;
3274 if (std::strcmp(uri, LV2_EXTERNAL_UI__Widget) == 0)
3275 return true;
3276 if (std::strcmp(uri, LV2_EXTERNAL_UI_DEPRECATED_URI) == 0)
3277 return true;
3278 return false;
3279 }
3280
3281 // --------------------------------------------------------------------------------------------------------------------
3282
3283 #endif // CARLA_LV2_UTILS_HPP_INCLUDED