1 /*
2 * Carla Backend utils
3 * Copyright (C) 2011-2021 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_BACKEND_UTILS_HPP_INCLUDED
19 #define CARLA_BACKEND_UTILS_HPP_INCLUDED
20
21 #include "CarlaBackend.h"
22 #include "CarlaString.hpp"
23
24 CARLA_BACKEND_START_NAMESPACE
25
26 // -----------------------------------------------------------------------
27
28 static inline
PluginOption2Str(const uint option)29 const char* PluginOption2Str(const uint option) noexcept
30 {
31 switch (option)
32 {
33 case PLUGIN_OPTION_FIXED_BUFFERS:
34 return "PLUGIN_OPTION_FIXED_BUFFERS";
35 case PLUGIN_OPTION_FORCE_STEREO:
36 return "PLUGIN_OPTION_FORCE_STEREO";
37 case PLUGIN_OPTION_MAP_PROGRAM_CHANGES:
38 return "PLUGIN_OPTION_MAP_PROGRAM_CHANGES";
39 case PLUGIN_OPTION_USE_CHUNKS:
40 return "PLUGIN_OPTION_USE_CHUNKS";
41 case PLUGIN_OPTION_SEND_CONTROL_CHANGES:
42 return "PLUGIN_OPTION_SEND_CONTROL_CHANGES";
43 case PLUGIN_OPTION_SEND_CHANNEL_PRESSURE:
44 return "PLUGIN_OPTION_SEND_CHANNEL_PRESSURE";
45 case PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH:
46 return "PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH";
47 case PLUGIN_OPTION_SEND_PITCHBEND:
48 return "PLUGIN_OPTION_SEND_PITCHBEND";
49 case PLUGIN_OPTION_SEND_ALL_SOUND_OFF:
50 return "PLUGIN_OPTION_SEND_ALL_SOUND_OFF";
51 }
52
53 carla_stderr("CarlaBackend::PluginOption2Str(%i) - invalid option", option);
54 return nullptr;
55 }
56
57 // -----------------------------------------------------------------------
58
59 static inline
BinaryType2Str(const BinaryType type)60 const char* BinaryType2Str(const BinaryType type) noexcept
61 {
62 switch (type)
63 {
64 case BINARY_NONE:
65 return "BINARY_NONE";
66 case BINARY_POSIX32:
67 return "BINARY_POSIX32";
68 case BINARY_POSIX64:
69 return "BINARY_POSIX64";
70 case BINARY_WIN32:
71 return "BINARY_WIN32";
72 case BINARY_WIN64:
73 return "BINARY_WIN64";
74 case BINARY_OTHER:
75 return "BINARY_OTHER";
76 }
77
78 carla_stderr("CarlaBackend::BinaryType2Str(%i) - invalid type", type);
79 return nullptr;
80 }
81
82 static inline
FileType2Str(const FileType type)83 const char* FileType2Str(const FileType type) noexcept
84 {
85 switch (type)
86 {
87 case FILE_NONE:
88 return "FILE_NONE";
89 case FILE_AUDIO:
90 return "FILE_AUDIO";
91 case FILE_MIDI:
92 return "FILE_MIDI";
93 }
94
95 carla_stderr("CarlaBackend::FileType2Str(%i) - invalid type", type);
96 return nullptr;
97 }
98
99 static inline
PluginType2Str(const PluginType type)100 const char* PluginType2Str(const PluginType type) noexcept
101 {
102 switch (type)
103 {
104 case PLUGIN_NONE:
105 return "PLUGIN_NONE";
106 case PLUGIN_INTERNAL:
107 return "PLUGIN_INTERNAL";
108 case PLUGIN_LADSPA:
109 return "PLUGIN_LADSPA";
110 case PLUGIN_DSSI:
111 return "PLUGIN_DSSI";
112 case PLUGIN_LV2:
113 return "PLUGIN_LV2";
114 case PLUGIN_VST2:
115 return "PLUGIN_VST2";
116 case PLUGIN_VST3:
117 return "PLUGIN_VST3";
118 case PLUGIN_AU:
119 return "PLUGIN_AU";
120 case PLUGIN_DLS:
121 return "PLUGIN_DLS";
122 case PLUGIN_GIG:
123 return "PLUGIN_GIG";
124 case PLUGIN_SF2:
125 return "PLUGIN_SF2";
126 case PLUGIN_SFZ:
127 return "PLUGIN_SFZ";
128 case PLUGIN_JACK:
129 return "PLUGIN_JACK";
130 }
131
132 carla_stderr("CarlaBackend::PluginType2Str(%i) - invalid type", type);
133 return nullptr;
134 }
135
136 static inline
PluginCategory2Str(const PluginCategory category)137 const char* PluginCategory2Str(const PluginCategory category) noexcept
138 {
139 switch (category)
140 {
141 case PLUGIN_CATEGORY_NONE:
142 return "PLUGIN_CATEGORY_NONE";
143 case PLUGIN_CATEGORY_SYNTH:
144 return "PLUGIN_CATEGORY_SYNTH";
145 case PLUGIN_CATEGORY_DELAY:
146 return "PLUGIN_CATEGORY_DELAY";
147 case PLUGIN_CATEGORY_EQ:
148 return "PLUGIN_CATEGORY_EQ";
149 case PLUGIN_CATEGORY_FILTER:
150 return "PLUGIN_CATEGORY_FILTER";
151 case PLUGIN_CATEGORY_DISTORTION:
152 return "PLUGIN_CATEGORY_DISTORTION";
153 case PLUGIN_CATEGORY_DYNAMICS:
154 return "PLUGIN_CATEGORY_DYNAMICS";
155 case PLUGIN_CATEGORY_MODULATOR:
156 return "PLUGIN_CATEGORY_MODULATOR";
157 case PLUGIN_CATEGORY_UTILITY:
158 return "PLUGIN_CATEGORY_UTILITY";
159 case PLUGIN_CATEGORY_OTHER:
160 return "PLUGIN_CATEGORY_OTHER";
161 }
162
163 carla_stderr("CarlaBackend::PluginCategory2Str(%i) - invalid category", category);
164 return nullptr;
165 }
166
167 static inline
ParameterType2Str(const ParameterType type)168 const char* ParameterType2Str(const ParameterType type) noexcept
169 {
170 switch (type)
171 {
172 case PARAMETER_UNKNOWN:
173 return "PARAMETER_UNKNOWN";
174 case PARAMETER_INPUT:
175 return "PARAMETER_INPUT";
176 case PARAMETER_OUTPUT:
177 return "PARAMETER_OUTPUT";
178 }
179
180 carla_stderr("CarlaBackend::ParameterType2Str(%i) - invalid type", type);
181 return nullptr;
182 }
183
184 static inline
InternalParameterIndex2Str(const InternalParameterIndex index)185 const char* InternalParameterIndex2Str(const InternalParameterIndex index) noexcept
186 {
187 switch (index)
188 {
189 case PARAMETER_NULL:
190 return "PARAMETER_NULL";
191 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
192 case PARAMETER_ACTIVE:
193 return "PARAMETER_ACTIVE";
194 case PARAMETER_DRYWET:
195 return "PARAMETER_DRYWET";
196 case PARAMETER_VOLUME:
197 return "PARAMETER_VOLUME";
198 case PARAMETER_BALANCE_LEFT:
199 return "PARAMETER_BALANCE_LEFT";
200 case PARAMETER_BALANCE_RIGHT:
201 return "PARAMETER_BALANCE_RIGHT";
202 case PARAMETER_PANNING:
203 return "PARAMETER_PANNING";
204 case PARAMETER_CTRL_CHANNEL:
205 return "PARAMETER_CTRL_CHANNEL";
206 #endif
207 case PARAMETER_MAX:
208 return "PARAMETER_MAX";
209 }
210
211 carla_stderr("CarlaBackend::InternalParameterIndex2Str(%i) - invalid index", index);
212 return nullptr;
213 }
214
215 static inline
EngineCallbackOpcode2Str(const EngineCallbackOpcode opcode)216 const char* EngineCallbackOpcode2Str(const EngineCallbackOpcode opcode) noexcept
217 {
218 switch (opcode)
219 {
220 case ENGINE_CALLBACK_DEBUG:
221 return "ENGINE_CALLBACK_DEBUG";
222 case ENGINE_CALLBACK_PLUGIN_ADDED:
223 return "ENGINE_CALLBACK_PLUGIN_ADDED";
224 case ENGINE_CALLBACK_PLUGIN_REMOVED:
225 return "ENGINE_CALLBACK_PLUGIN_REMOVED";
226 case ENGINE_CALLBACK_PLUGIN_RENAMED:
227 return "ENGINE_CALLBACK_PLUGIN_RENAMED";
228 case ENGINE_CALLBACK_PLUGIN_UNAVAILABLE:
229 return "ENGINE_CALLBACK_PLUGIN_UNAVAILABLE";
230 case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED:
231 return "ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED";
232 case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED:
233 return "ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED";
234 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
235 case ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED:
236 return "ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED";
237 case ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED:
238 return "ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED";
239 case ENGINE_CALLBACK_OPTION_CHANGED:
240 return "ENGINE_CALLBACK_OPTION_CHANGED";
241 #endif
242 case ENGINE_CALLBACK_PROGRAM_CHANGED:
243 return "ENGINE_CALLBACK_PROGRAM_CHANGED";
244 case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED:
245 return "ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED";
246 case ENGINE_CALLBACK_UI_STATE_CHANGED:
247 return "ENGINE_CALLBACK_UI_STATE_CHANGED";
248 case ENGINE_CALLBACK_NOTE_ON:
249 return "ENGINE_CALLBACK_NOTE_ON";
250 case ENGINE_CALLBACK_NOTE_OFF:
251 return "ENGINE_CALLBACK_NOTE_OFF";
252 case ENGINE_CALLBACK_UPDATE:
253 return "ENGINE_CALLBACK_UPDATE";
254 case ENGINE_CALLBACK_RELOAD_INFO:
255 return "ENGINE_CALLBACK_RELOAD_INFO";
256 case ENGINE_CALLBACK_RELOAD_PARAMETERS:
257 return "ENGINE_CALLBACK_RELOAD_PARAMETERS";
258 case ENGINE_CALLBACK_RELOAD_PROGRAMS:
259 return "ENGINE_CALLBACK_RELOAD_PROGRAMS";
260 case ENGINE_CALLBACK_RELOAD_ALL:
261 return "ENGINE_CALLBACK_RELOAD_ALL";
262 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
263 case ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED:
264 return "ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED";
265 case ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED:
266 return "ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED";
267 case ENGINE_CALLBACK_PATCHBAY_CLIENT_RENAMED:
268 return "ENGINE_CALLBACK_PATCHBAY_CLIENT_RENAMED";
269 case ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED:
270 return "ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED";
271 case ENGINE_CALLBACK_PATCHBAY_PORT_ADDED:
272 return "ENGINE_CALLBACK_PATCHBAY_PORT_ADDED";
273 case ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED:
274 return "ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED";
275 case ENGINE_CALLBACK_PATCHBAY_PORT_CHANGED:
276 return "ENGINE_CALLBACK_PATCHBAY_PORT_CHANGED";
277 case ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED:
278 return "ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED";
279 case ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED:
280 return "ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED";
281 #endif
282 case ENGINE_CALLBACK_ENGINE_STARTED:
283 return "ENGINE_CALLBACK_ENGINE_STARTED";
284 case ENGINE_CALLBACK_ENGINE_STOPPED:
285 return "ENGINE_CALLBACK_ENGINE_STOPPED";
286 case ENGINE_CALLBACK_PROCESS_MODE_CHANGED:
287 return "ENGINE_CALLBACK_PROCESS_MODE_CHANGED";
288 case ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED:
289 return "ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED";
290 case ENGINE_CALLBACK_BUFFER_SIZE_CHANGED:
291 return "ENGINE_CALLBACK_BUFFER_SIZE_CHANGED";
292 case ENGINE_CALLBACK_SAMPLE_RATE_CHANGED:
293 return "ENGINE_CALLBACK_SAMPLE_RATE_CHANGED";
294 case ENGINE_CALLBACK_CANCELABLE_ACTION:
295 return "ENGINE_CALLBACK_CANCELABLE_ACTION";
296 case ENGINE_CALLBACK_PROJECT_LOAD_FINISHED:
297 return "ENGINE_CALLBACK_PROJECT_LOAD_FINISHED";
298 case ENGINE_CALLBACK_NSM:
299 return "ENGINE_CALLBACK_NSM";
300 case ENGINE_CALLBACK_IDLE:
301 return "ENGINE_CALLBACK_IDLE";
302 case ENGINE_CALLBACK_INFO:
303 return "ENGINE_CALLBACK_INFO";
304 case ENGINE_CALLBACK_ERROR:
305 return "ENGINE_CALLBACK_ERROR";
306 case ENGINE_CALLBACK_QUIT:
307 return "ENGINE_CALLBACK_QUIT";
308 case ENGINE_CALLBACK_INLINE_DISPLAY_REDRAW:
309 return "ENGINE_CALLBACK_INLINE_DISPLAY_REDRAW";
310 case ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_ADDED:
311 return "ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_ADDED";
312 case ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_REMOVED:
313 return "ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_REMOVED";
314 case ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_CHANGED:
315 return "ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_CHANGED";
316 case ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED:
317 return "ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED";
318 case ENGINE_CALLBACK_PATCHBAY_CLIENT_POSITION_CHANGED:
319 return "ENGINE_CALLBACK_PATCHBAY_CLIENT_POSITION_CHANGED";
320 case ENGINE_CALLBACK_EMBED_UI_RESIZED:
321 return "ENGINE_CALLBACK_EMBED_UI_RESIZED";
322 }
323
324 carla_stderr("CarlaBackend::EngineCallbackOpcode2Str(%i) - invalid opcode", opcode);
325 return nullptr;
326 }
327
328 static inline
EngineOption2Str(const EngineOption option)329 const char* EngineOption2Str(const EngineOption option) noexcept
330 {
331 switch (option)
332 {
333 case ENGINE_OPTION_DEBUG:
334 return "ENGINE_OPTION_DEBUG";
335 case ENGINE_OPTION_PROCESS_MODE:
336 return "ENGINE_OPTION_PROCESS_MODE";
337 case ENGINE_OPTION_TRANSPORT_MODE:
338 return "ENGINE_OPTION_TRANSPORT_MODE";
339 case ENGINE_OPTION_FORCE_STEREO:
340 return "ENGINE_OPTION_FORCE_STEREO";
341 case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:
342 return "ENGINE_OPTION_PREFER_PLUGIN_BRIDGES";
343 case ENGINE_OPTION_PREFER_UI_BRIDGES:
344 return "ENGINE_OPTION_PREFER_UI_BRIDGES";
345 case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:
346 return "ENGINE_OPTION_UIS_ALWAYS_ON_TOP";
347 case ENGINE_OPTION_MAX_PARAMETERS:
348 return "ENGINE_OPTION_MAX_PARAMETERS";
349 case ENGINE_OPTION_RESET_XRUNS:
350 return "ENGINE_OPTION_RESET_XRUNS";
351 case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:
352 return "ENGINE_OPTION_UI_BRIDGES_TIMEOUT";
353 case ENGINE_OPTION_AUDIO_BUFFER_SIZE:
354 return "ENGINE_OPTION_AUDIO_BUFFER_SIZE";
355 case ENGINE_OPTION_AUDIO_SAMPLE_RATE:
356 return "ENGINE_OPTION_AUDIO_SAMPLE_RATE";
357 case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:
358 return "ENGINE_OPTION_AUDIO_TRIPLE_BUFFER";
359 case ENGINE_OPTION_AUDIO_DRIVER:
360 return "ENGINE_OPTION_AUDIO_DRIVER";
361 case ENGINE_OPTION_AUDIO_DEVICE:
362 return "ENGINE_OPTION_AUDIO_DEVICE";
363 #ifndef BUILD_BRIDGE
364 case ENGINE_OPTION_OSC_ENABLED:
365 return "ENGINE_OPTION_OSC_ENABLED";
366 case ENGINE_OPTION_OSC_PORT_UDP:
367 return "ENGINE_OPTION_OSC_PORT_UDP";
368 case ENGINE_OPTION_OSC_PORT_TCP:
369 return "ENGINE_OPTION_OSC_PORT_TCP";
370 #endif
371 case ENGINE_OPTION_FILE_PATH:
372 return "ENGINE_OPTION_FILE_PATH";
373 case ENGINE_OPTION_PLUGIN_PATH:
374 return "ENGINE_OPTION_PLUGIN_PATH";
375 case ENGINE_OPTION_PATH_BINARIES:
376 return "ENGINE_OPTION_PATH_BINARIES";
377 case ENGINE_OPTION_PATH_RESOURCES:
378 return "ENGINE_OPTION_PATH_RESOURCES";
379 case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:
380 return "ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR";
381 case ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:
382 return "ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR";
383 case ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:
384 return "ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR";
385 case ENGINE_OPTION_FRONTEND_UI_SCALE:
386 return "ENGINE_OPTION_FRONTEND_UI_SCALE";
387 case ENGINE_OPTION_FRONTEND_WIN_ID:
388 return "ENGINE_OPTION_FRONTEND_WIN_ID";
389 #if !defined(BUILD_BRIDGE_ALTERNATIVE_ARCH) && !defined(CARLA_OS_WIN)
390 case ENGINE_OPTION_WINE_EXECUTABLE:
391 return "ENGINE_OPTION_WINE_EXECUTABLE";
392 case ENGINE_OPTION_WINE_AUTO_PREFIX:
393 return "ENGINE_OPTION_WINE_AUTO_PREFIX";
394 case ENGINE_OPTION_WINE_FALLBACK_PREFIX:
395 return "ENGINE_OPTION_WINE_FALLBACK_PREFIX";
396 case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:
397 return "ENGINE_OPTION_WINE_RT_PRIO_ENABLED";
398 case ENGINE_OPTION_WINE_BASE_RT_PRIO:
399 return "ENGINE_OPTION_WINE_BASE_RT_PRIO";
400 case ENGINE_OPTION_WINE_SERVER_RT_PRIO:
401 return "ENGINE_OPTION_WINE_SERVER_RT_PRIO";
402 #endif
403 #ifndef BUILD_BRIDGE
404 case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:
405 return "ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT";
406 #endif
407 case ENGINE_OPTION_CLIENT_NAME_PREFIX:
408 return "ENGINE_OPTION_CLIENT_NAME_PREFIX";
409 case ENGINE_OPTION_PLUGINS_ARE_STANDALONE:
410 return "ENGINE_OPTION_PLUGINS_ARE_STANDALONE";
411 }
412
413 carla_stderr("CarlaBackend::EngineOption2Str(%i) - invalid option", option);
414 return nullptr;
415 }
416
417 static inline
EngineProcessMode2Str(const EngineProcessMode mode)418 const char* EngineProcessMode2Str(const EngineProcessMode mode) noexcept
419 {
420 switch (mode)
421 {
422 case ENGINE_PROCESS_MODE_SINGLE_CLIENT:
423 return "ENGINE_PROCESS_MODE_SINGLE_CLIENT";
424 case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:
425 return "ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS";
426 case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:
427 return "ENGINE_PROCESS_MODE_CONTINUOUS_RACK";
428 case ENGINE_PROCESS_MODE_PATCHBAY:
429 return "ENGINE_PROCESS_MODE_PATCHBAY";
430 case ENGINE_PROCESS_MODE_BRIDGE:
431 return "ENGINE_PROCESS_MODE_BRIDGE";
432 }
433
434 carla_stderr("CarlaBackend::EngineProcessMode2Str(%i) - invalid mode", mode);
435 return nullptr;
436 }
437
438 static inline
EngineTransportMode2Str(const EngineTransportMode mode)439 const char* EngineTransportMode2Str(const EngineTransportMode mode) noexcept
440 {
441 switch (mode)
442 {
443 case ENGINE_TRANSPORT_MODE_DISABLED:
444 return "ENGINE_TRANSPORT_MODE_DISABLED";
445 case ENGINE_TRANSPORT_MODE_INTERNAL:
446 return "ENGINE_TRANSPORT_MODE_INTERNAL";
447 case ENGINE_TRANSPORT_MODE_JACK:
448 return "ENGINE_TRANSPORT_MODE_JACK";
449 case ENGINE_TRANSPORT_MODE_PLUGIN:
450 return "ENGINE_TRANSPORT_MODE_PLUGIN";
451 case ENGINE_TRANSPORT_MODE_BRIDGE:
452 return "ENGINE_TRANSPORT_MODE_BRIDGE";
453 }
454
455 carla_stderr("CarlaBackend::EngineTransportMode2Str(%i) - invalid mode", mode);
456 return nullptr;
457 }
458
459 static inline
FileCallbackOpcode2Str(const FileCallbackOpcode opcode)460 const char* FileCallbackOpcode2Str(const FileCallbackOpcode opcode) noexcept
461 {
462 switch (opcode)
463 {
464 case FILE_CALLBACK_DEBUG:
465 return "FILE_CALLBACK_DEBUG";
466 case FILE_CALLBACK_OPEN:
467 return "FILE_CALLBACK_OPEN";
468 case FILE_CALLBACK_SAVE:
469 return "FILE_CALLBACK_SAVE";
470 }
471
472 carla_stderr("CarlaBackend::FileCallbackOpcode2Str(%i) - invalid opcode", opcode);
473 return nullptr;
474 }
475
476 static inline
PatchbayIcon2Str(const PatchbayIcon icon)477 const char* PatchbayIcon2Str(const PatchbayIcon icon) noexcept
478 {
479 switch (icon)
480 {
481 case PATCHBAY_ICON_APPLICATION:
482 return "PATCHBAY_ICON_APPLICATION";
483 case PATCHBAY_ICON_PLUGIN:
484 return "PATCHBAY_ICON_PLUGIN";
485 case PATCHBAY_ICON_HARDWARE:
486 return "PATCHBAY_ICON_HARDWARE";
487 case PATCHBAY_ICON_CARLA:
488 return "PATCHBAY_ICON_CARLA";
489 case PATCHBAY_ICON_DISTRHO:
490 return "PATCHBAY_ICON_DISTRHO";
491 case PATCHBAY_ICON_FILE:
492 return "PATCHBAY_ICON_FILE";
493 }
494
495 carla_stderr("CarlaBackend::PatchbayIcon2Str(%i) - invalid icon", icon);
496 return nullptr;
497 }
498
499 // -----------------------------------------------------------------------
500
501 static inline
getBinaryTypeFromString(const char * const ctype)502 BinaryType getBinaryTypeFromString(const char* const ctype) noexcept
503 {
504 CARLA_SAFE_ASSERT_RETURN(ctype != nullptr && ctype[0] != '\0', BINARY_NONE);
505 carla_debug("CarlaBackend::getBinaryTypeFromString(\"%s\")", ctype);
506
507 CarlaString stype(ctype);
508
509 if (stype.isEmpty())
510 return BINARY_NONE;
511
512 stype.toLower();
513
514 if (stype == "none")
515 return BINARY_NONE;
516 if (stype == "native")
517 return BINARY_NATIVE;
518 if (stype == "posix32" || stype == "linux32" || stype == "mac32")
519 return BINARY_POSIX32;
520 if (stype == "posix64" || stype == "linux64" || stype == "mac64")
521 return BINARY_POSIX64;
522 if (stype == "win32")
523 return BINARY_WIN32;
524 if (stype == "win64")
525 return BINARY_WIN64;
526
527 carla_stderr("CarlaBackend::getBinaryTypeFromString(\"%s\") - invalid string type", ctype);
528 return BINARY_NONE;
529 }
530
531 // -----------------------------------------------------------------------
532
533 static inline
getPluginCategoryAsString(const PluginCategory category)534 const char* getPluginCategoryAsString(const PluginCategory category) noexcept
535 {
536 carla_debug("CarlaBackend::getPluginCategoryAsString(%i:%s)", category, PluginCategory2Str(category));
537
538 switch (category)
539 {
540 case PLUGIN_CATEGORY_NONE:
541 return "none";
542 case PLUGIN_CATEGORY_SYNTH:
543 return "synth";
544 case PLUGIN_CATEGORY_DELAY:
545 return "delay";
546 case PLUGIN_CATEGORY_EQ:
547 return "eq";
548 case PLUGIN_CATEGORY_FILTER:
549 return "filter";
550 case PLUGIN_CATEGORY_DISTORTION:
551 return "distortion";
552 case PLUGIN_CATEGORY_DYNAMICS:
553 return "dynamics";
554 case PLUGIN_CATEGORY_MODULATOR:
555 return "modulator";
556 case PLUGIN_CATEGORY_UTILITY:
557 return "utility";
558 case PLUGIN_CATEGORY_OTHER:
559 return "other";
560 }
561
562 carla_stderr("CarlaBackend::getPluginCategoryAsString(%i) - invalid category", category);
563 return "NONE";
564 }
565
566 static inline
getPluginTypeAsString(const PluginType type)567 const char* getPluginTypeAsString(const PluginType type) noexcept
568 {
569 carla_debug("CarlaBackend::getPluginTypeAsString(%i:%s)", type, PluginType2Str(type));
570
571 switch (type)
572 {
573 case PLUGIN_NONE:
574 return "NONE";
575 case PLUGIN_INTERNAL:
576 return "INTERNAL";
577 case PLUGIN_LADSPA:
578 return "LADSPA";
579 case PLUGIN_DSSI:
580 return "DSSI";
581 case PLUGIN_LV2:
582 return "LV2";
583 case PLUGIN_VST2:
584 return "VST2";
585 case PLUGIN_VST3:
586 return "VST3";
587 case PLUGIN_AU:
588 return "AU";
589 case PLUGIN_DLS:
590 return "DLS";
591 case PLUGIN_GIG:
592 return "GIG";
593 case PLUGIN_SF2:
594 return "SF2";
595 case PLUGIN_SFZ:
596 return "SFZ";
597 case PLUGIN_JACK:
598 return "JACK";
599 }
600
601 carla_stderr("CarlaBackend::getPluginTypeAsString(%i) - invalid type", type);
602 return "NONE";
603 }
604
605 static inline
getPluginTypeFromString(const char * const ctype)606 PluginType getPluginTypeFromString(const char* const ctype) noexcept
607 {
608 CARLA_SAFE_ASSERT_RETURN(ctype != nullptr && ctype[0] != '\0', PLUGIN_NONE);
609 carla_debug("CarlaBackend::getPluginTypeFromString(\"%s\")", ctype);
610
611 CarlaString stype(ctype);
612
613 if (stype.isEmpty())
614 return PLUGIN_NONE;
615
616 stype.toLower();
617
618 if (stype == "none")
619 return PLUGIN_NONE;
620 if (stype == "internal" || stype == "native")
621 return PLUGIN_INTERNAL;
622 if (stype == "ladspa")
623 return PLUGIN_LADSPA;
624 if (stype == "dssi")
625 return PLUGIN_DSSI;
626 if (stype == "lv2")
627 return PLUGIN_LV2;
628 if (stype == "vst2" || stype == "vst")
629 return PLUGIN_VST2;
630 if (stype == "vst3")
631 return PLUGIN_VST3;
632 if (stype == "au" || stype == "audiounit")
633 return PLUGIN_AU;
634 if (stype == "dls")
635 return PLUGIN_DLS;
636 if (stype == "gig")
637 return PLUGIN_GIG;
638 if (stype == "sf2" || stype == "sf3")
639 return PLUGIN_SF2;
640 if (stype == "sfz")
641 return PLUGIN_SFZ;
642 if (stype == "jack")
643 return PLUGIN_JACK;
644
645 carla_stderr("CarlaBackend::getPluginTypeFromString(\"%s\") - invalid string type", ctype);
646 return PLUGIN_NONE;
647 }
648
649 // -----------------------------------------------------------------------
650
651 static inline
getPluginCategoryFromName(const char * const name)652 PluginCategory getPluginCategoryFromName(const char* const name) noexcept
653 {
654 CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', PLUGIN_CATEGORY_NONE);
655 carla_debug("CarlaBackend::getPluginCategoryFromName(\"%s\")", name);
656
657 CarlaString sname(name);
658
659 if (sname.isEmpty())
660 return PLUGIN_CATEGORY_NONE;
661
662 sname.toLower();
663
664 // generic tags first
665 if (sname.contains("delay"))
666 return PLUGIN_CATEGORY_DELAY;
667 if (sname.contains("reverb"))
668 return PLUGIN_CATEGORY_DELAY;
669
670 // filter
671 if (sname.contains("filter"))
672 return PLUGIN_CATEGORY_FILTER;
673
674 // distortion
675 if (sname.contains("distortion"))
676 return PLUGIN_CATEGORY_DISTORTION;
677
678 // dynamics
679 if (sname.contains("dynamics"))
680 return PLUGIN_CATEGORY_DYNAMICS;
681 if (sname.contains("amplifier"))
682 return PLUGIN_CATEGORY_DYNAMICS;
683 if (sname.contains("compressor"))
684 return PLUGIN_CATEGORY_DYNAMICS;
685 if (sname.contains("enhancer"))
686 return PLUGIN_CATEGORY_DYNAMICS;
687 if (sname.contains("exciter"))
688 return PLUGIN_CATEGORY_DYNAMICS;
689 if (sname.contains("gate"))
690 return PLUGIN_CATEGORY_DYNAMICS;
691 if (sname.contains("limiter"))
692 return PLUGIN_CATEGORY_DYNAMICS;
693
694 // modulator
695 if (sname.contains("modulator"))
696 return PLUGIN_CATEGORY_MODULATOR;
697 if (sname.contains("chorus"))
698 return PLUGIN_CATEGORY_MODULATOR;
699 if (sname.contains("flanger"))
700 return PLUGIN_CATEGORY_MODULATOR;
701 if (sname.contains("phaser"))
702 return PLUGIN_CATEGORY_MODULATOR;
703 if (sname.contains("saturator"))
704 return PLUGIN_CATEGORY_MODULATOR;
705
706 // utility
707 if (sname.contains("utility"))
708 return PLUGIN_CATEGORY_UTILITY;
709 if (sname.contains("analyzer"))
710 return PLUGIN_CATEGORY_UTILITY;
711 if (sname.contains("converter"))
712 return PLUGIN_CATEGORY_UTILITY;
713 if (sname.contains("deesser"))
714 return PLUGIN_CATEGORY_UTILITY;
715 if (sname.contains("mixer"))
716 return PLUGIN_CATEGORY_UTILITY;
717
718 // common tags
719 if (sname.contains("verb"))
720 return PLUGIN_CATEGORY_DELAY;
721
722 if (sname.contains("eq"))
723 return PLUGIN_CATEGORY_EQ;
724
725 if (sname.contains("tool"))
726 return PLUGIN_CATEGORY_UTILITY;
727
728 // synth
729 if (sname.contains("synth"))
730 return PLUGIN_CATEGORY_SYNTH;
731
732 // other
733 if (sname.contains("misc"))
734 return PLUGIN_CATEGORY_OTHER;
735 if (sname.contains("other"))
736 return PLUGIN_CATEGORY_OTHER;
737
738 return PLUGIN_CATEGORY_NONE;
739 }
740
741 // -----------------------------------------------------------------------
742
743 static inline
isPluginOptionEnabled(const uint options,const uint option)744 bool isPluginOptionEnabled(const uint options, const uint option)
745 {
746 if (options == PLUGIN_OPTIONS_NULL)
747 return true;
748 if (options & option)
749 return true;
750 return false;
751 }
752
753 static inline
isPluginOptionInverseEnabled(const uint options,const uint option)754 bool isPluginOptionInverseEnabled(const uint options, const uint option)
755 {
756 if (options == PLUGIN_OPTIONS_NULL)
757 return false;
758 if (options & option)
759 return true;
760 return false;
761 }
762
763 // -----------------------------------------------------------------------
764
765 CARLA_BACKEND_END_NAMESPACE
766
767 #endif // CARLA_BACKEND_UTILS_HPP_INCLUDED
768