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

922 lines
29KB
Raw Blame History 

  1. /*

  2.  * Carla Backend utils

  3.  * Copyright (C) 2011-2024 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 "CarlaNative.h"

  23. #include "CarlaString.hpp"

  24. 

  25. CARLA_BACKEND_START_NAMESPACE

  26. 

  27. // -----------------------------------------------------------------------

  28. 

  29. static inline

  30. const char* PluginOption2Str(const uint option) noexcept

  31. {

  32.     switch (option)

  33.     {

  34.     case PLUGIN_OPTION_FIXED_BUFFERS:

  35.         return "PLUGIN_OPTION_FIXED_BUFFERS";

  36.     case PLUGIN_OPTION_FORCE_STEREO:

  37.         return "PLUGIN_OPTION_FORCE_STEREO";

  38.     case PLUGIN_OPTION_MAP_PROGRAM_CHANGES:

  39.         return "PLUGIN_OPTION_MAP_PROGRAM_CHANGES";

  40.     case PLUGIN_OPTION_USE_CHUNKS:

  41.         return "PLUGIN_OPTION_USE_CHUNKS";

  42.     case PLUGIN_OPTION_SEND_CONTROL_CHANGES:

  43.         return "PLUGIN_OPTION_SEND_CONTROL_CHANGES";

  44.     case PLUGIN_OPTION_SEND_CHANNEL_PRESSURE:

  45.         return "PLUGIN_OPTION_SEND_CHANNEL_PRESSURE";

  46.     case PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH:

  47.         return "PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH";

  48.     case PLUGIN_OPTION_SEND_PITCHBEND:

  49.         return "PLUGIN_OPTION_SEND_PITCHBEND";

  50.     case PLUGIN_OPTION_SEND_ALL_SOUND_OFF:

  51.         return "PLUGIN_OPTION_SEND_ALL_SOUND_OFF";

  52.     }

  53. 

  54.     carla_stderr("CarlaBackend::PluginOption2Str(%i) - invalid option", option);

  55.     return "";

  56. }

  57. 

  58. // -----------------------------------------------------------------------

  59. 

  60. static inline

  61. const char* BinaryType2Str(const BinaryType type) noexcept

  62. {

  63.     switch (type)

  64.     {

  65.     case BINARY_NONE:

  66.         return "BINARY_NONE";

  67.     case BINARY_POSIX32:

  68.         return "BINARY_POSIX32";

  69.     case BINARY_POSIX64:

  70.         return "BINARY_POSIX64";

  71.     case BINARY_WIN32:

  72.         return "BINARY_WIN32";

  73.     case BINARY_WIN64:

  74.         return "BINARY_WIN64";

  75.     case BINARY_OTHER:

  76.         return "BINARY_OTHER";

  77.     }

  78. 

  79.     carla_stderr("CarlaBackend::BinaryType2Str(%i) - invalid type", type);

  80.     return "";

  81. }

  82. 

  83. static inline

  84. const char* FileType2Str(const FileType type) noexcept

  85. {

  86.     switch (type)

  87.     {

  88.     case FILE_NONE:

  89.         return "FILE_NONE";

  90.     case FILE_AUDIO:

  91.         return "FILE_AUDIO";

  92.     case FILE_MIDI:

  93.         return "FILE_MIDI";

  94.     }

  95. 

  96.     carla_stderr("CarlaBackend::FileType2Str(%i) - invalid type", type);

  97.     return "";

  98. }

  99. 

  100. static inline

  101. const char* PluginType2Str(const PluginType type) noexcept

  102. {

  103.     switch (type)

  104.     {

  105.     case PLUGIN_NONE:

  106.         return "PLUGIN_NONE";

  107.     case PLUGIN_INTERNAL:

  108.         return "PLUGIN_INTERNAL";

  109.     case PLUGIN_LADSPA:

  110.         return "PLUGIN_LADSPA";

  111.     case PLUGIN_DSSI:

  112.         return "PLUGIN_DSSI";

  113.     case PLUGIN_LV2:

  114.         return "PLUGIN_LV2";

  115.     case PLUGIN_VST2:

  116.         return "PLUGIN_VST2";

  117.     case PLUGIN_VST3:

  118.         return "PLUGIN_VST3";

  119.     case PLUGIN_AU:

  120.         return "PLUGIN_AU";

  121.     case PLUGIN_DLS:

  122.         return "PLUGIN_DLS";

  123.     case PLUGIN_GIG:

  124.         return "PLUGIN_GIG";

  125.     case PLUGIN_SF2:

  126.         return "PLUGIN_SF2";

  127.     case PLUGIN_SFZ:

  128.         return "PLUGIN_SFZ";

  129.     case PLUGIN_JACK:

  130.         return "PLUGIN_JACK";

  131.     case PLUGIN_JSFX:

  132.         return "PLUGIN_JSFX";

  133.     case PLUGIN_CLAP:

  134.         return "PLUGIN_CLAP";

  135.     case PLUGIN_TYPE_COUNT:

  136.         break;

  137.     }

  138. 

  139.     carla_stderr("CarlaBackend::PluginType2Str(%i) - invalid type", type);

  140.     return "";

  141. }

  142. 

  143. static inline

  144. const char* PluginCategory2Str(const PluginCategory category) noexcept

  145. {

  146.     switch (category)

  147.     {

  148.     case PLUGIN_CATEGORY_NONE:

  149.         return "PLUGIN_CATEGORY_NONE";

  150.     case PLUGIN_CATEGORY_SYNTH:

  151.         return "PLUGIN_CATEGORY_SYNTH";

  152.     case PLUGIN_CATEGORY_DELAY:

  153.         return "PLUGIN_CATEGORY_DELAY";

  154.     case PLUGIN_CATEGORY_EQ:

  155.         return "PLUGIN_CATEGORY_EQ";

  156.     case PLUGIN_CATEGORY_FILTER:

  157.         return "PLUGIN_CATEGORY_FILTER";

  158.     case PLUGIN_CATEGORY_DISTORTION:

  159.         return "PLUGIN_CATEGORY_DISTORTION";

  160.     case PLUGIN_CATEGORY_DYNAMICS:

  161.         return "PLUGIN_CATEGORY_DYNAMICS";

  162.     case PLUGIN_CATEGORY_MODULATOR:

  163.         return "PLUGIN_CATEGORY_MODULATOR";

  164.     case PLUGIN_CATEGORY_UTILITY:

  165.         return "PLUGIN_CATEGORY_UTILITY";

  166.     case PLUGIN_CATEGORY_OTHER:

  167.         return "PLUGIN_CATEGORY_OTHER";

  168.     }

  169. 

  170.     carla_stderr("CarlaBackend::PluginCategory2Str(%i) - invalid category", category);

  171.     return "";

  172. }

  173. 

  174. static inline

  175. const char* ParameterType2Str(const ParameterType type) noexcept

  176. {

  177.     switch (type)

  178.     {

  179.     case PARAMETER_UNKNOWN:

  180.         return "PARAMETER_UNKNOWN";

  181.     case PARAMETER_INPUT:

  182.         return "PARAMETER_INPUT";

  183.     case PARAMETER_OUTPUT:

  184.         return "PARAMETER_OUTPUT";

  185.     }

  186. 

  187.     carla_stderr("CarlaBackend::ParameterType2Str(%i) - invalid type", type);

  188.     return "";

  189. }

  190. 

  191. static inline

  192. const char* InternalParameterIndex2Str(const InternalParameterIndex index) noexcept

  193. {

  194.     switch (index)

  195.     {

  196.     case PARAMETER_NULL:

  197.         return "PARAMETER_NULL";

  198. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  199.     case PARAMETER_ACTIVE:

  200.         return "PARAMETER_ACTIVE";

  201.     case PARAMETER_DRYWET:

  202.         return "PARAMETER_DRYWET";

  203.     case PARAMETER_VOLUME:

  204.         return "PARAMETER_VOLUME";

  205.     case PARAMETER_BALANCE_LEFT:

  206.         return "PARAMETER_BALANCE_LEFT";

  207.     case PARAMETER_BALANCE_RIGHT:

  208.         return "PARAMETER_BALANCE_RIGHT";

  209.     case PARAMETER_PANNING:

  210.         return "PARAMETER_PANNING";

  211.     case PARAMETER_CTRL_CHANNEL:

  212.         return "PARAMETER_CTRL_CHANNEL";

  213. #endif

  214.     case PARAMETER_MAX:

  215.         return "PARAMETER_MAX";

  216.     }

  217. 

  218.     carla_stderr("CarlaBackend::InternalParameterIndex2Str(%i) - invalid index", index);

  219.     return "";

  220. }

  221. 

  222. static inline

  223. const char* EngineCallbackOpcode2Str(const EngineCallbackOpcode opcode) noexcept

  224. {

  225.     switch (opcode)

  226.     {

  227.     case ENGINE_CALLBACK_DEBUG:

  228.         return "ENGINE_CALLBACK_DEBUG";

  229.     case ENGINE_CALLBACK_PLUGIN_ADDED:

  230.         return "ENGINE_CALLBACK_PLUGIN_ADDED";

  231.     case ENGINE_CALLBACK_PLUGIN_REMOVED:

  232.         return "ENGINE_CALLBACK_PLUGIN_REMOVED";

  233.     case ENGINE_CALLBACK_PLUGIN_RENAMED:

  234.         return "ENGINE_CALLBACK_PLUGIN_RENAMED";

  235.     case ENGINE_CALLBACK_PLUGIN_UNAVAILABLE:

  236.         return "ENGINE_CALLBACK_PLUGIN_UNAVAILABLE";

  237.     case ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED:

  238.         return "ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED";

  239.     case ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED:

  240.         return "ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED";

  241. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  242.     case ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED:

  243.         return "ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED";

  244.     case ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED:

  245.         return "ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED";

  246.     case ENGINE_CALLBACK_OPTION_CHANGED:

  247.         return "ENGINE_CALLBACK_OPTION_CHANGED";

  248. #endif

  249.     case ENGINE_CALLBACK_PROGRAM_CHANGED:

  250.         return "ENGINE_CALLBACK_PROGRAM_CHANGED";

  251.     case ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED:

  252.         return "ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED";

  253.     case ENGINE_CALLBACK_UI_STATE_CHANGED:

  254.         return "ENGINE_CALLBACK_UI_STATE_CHANGED";

  255.     case ENGINE_CALLBACK_NOTE_ON:

  256.         return "ENGINE_CALLBACK_NOTE_ON";

  257.     case ENGINE_CALLBACK_NOTE_OFF:

  258.         return "ENGINE_CALLBACK_NOTE_OFF";

  259.     case ENGINE_CALLBACK_UPDATE:

  260.         return "ENGINE_CALLBACK_UPDATE";

  261.     case ENGINE_CALLBACK_RELOAD_INFO:

  262.         return "ENGINE_CALLBACK_RELOAD_INFO";

  263.     case ENGINE_CALLBACK_RELOAD_PARAMETERS:

  264.         return "ENGINE_CALLBACK_RELOAD_PARAMETERS";

  265.     case ENGINE_CALLBACK_RELOAD_PROGRAMS:

  266.         return "ENGINE_CALLBACK_RELOAD_PROGRAMS";

  267.     case ENGINE_CALLBACK_RELOAD_ALL:

  268.         return "ENGINE_CALLBACK_RELOAD_ALL";

  269. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  270.     case ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED:

  271.         return "ENGINE_CALLBACK_PATCHBAY_CLIENT_ADDED";

  272.     case ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED:

  273.         return "ENGINE_CALLBACK_PATCHBAY_CLIENT_REMOVED";

  274.     case ENGINE_CALLBACK_PATCHBAY_CLIENT_RENAMED:

  275.         return "ENGINE_CALLBACK_PATCHBAY_CLIENT_RENAMED";

  276.     case ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED:

  277.         return "ENGINE_CALLBACK_PATCHBAY_CLIENT_DATA_CHANGED";

  278.     case ENGINE_CALLBACK_PATCHBAY_PORT_ADDED:

  279.         return "ENGINE_CALLBACK_PATCHBAY_PORT_ADDED";

  280.     case ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED:

  281.         return "ENGINE_CALLBACK_PATCHBAY_PORT_REMOVED";

  282.     case ENGINE_CALLBACK_PATCHBAY_PORT_CHANGED:

  283.         return "ENGINE_CALLBACK_PATCHBAY_PORT_CHANGED";

  284.     case ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED:

  285.         return "ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED";

  286.     case ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED:

  287.         return "ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED";

  288. #endif

  289.     case ENGINE_CALLBACK_ENGINE_STARTED:

  290.         return "ENGINE_CALLBACK_ENGINE_STARTED";

  291.     case ENGINE_CALLBACK_ENGINE_STOPPED:

  292.         return "ENGINE_CALLBACK_ENGINE_STOPPED";

  293.     case ENGINE_CALLBACK_PROCESS_MODE_CHANGED:

  294.         return "ENGINE_CALLBACK_PROCESS_MODE_CHANGED";

  295.     case ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED:

  296.         return "ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED";

  297.     case ENGINE_CALLBACK_BUFFER_SIZE_CHANGED:

  298.         return "ENGINE_CALLBACK_BUFFER_SIZE_CHANGED";

  299.     case ENGINE_CALLBACK_SAMPLE_RATE_CHANGED:

  300.         return "ENGINE_CALLBACK_SAMPLE_RATE_CHANGED";

  301.     case ENGINE_CALLBACK_CANCELABLE_ACTION:

  302.         return "ENGINE_CALLBACK_CANCELABLE_ACTION";

  303.     case ENGINE_CALLBACK_PROJECT_LOAD_FINISHED:

  304.         return "ENGINE_CALLBACK_PROJECT_LOAD_FINISHED";

  305.     case ENGINE_CALLBACK_NSM:

  306.         return "ENGINE_CALLBACK_NSM";

  307.     case ENGINE_CALLBACK_IDLE:

  308.         return "ENGINE_CALLBACK_IDLE";

  309.     case ENGINE_CALLBACK_INFO:

  310.         return "ENGINE_CALLBACK_INFO";

  311.     case ENGINE_CALLBACK_ERROR:

  312.         return "ENGINE_CALLBACK_ERROR";

  313.     case ENGINE_CALLBACK_QUIT:

  314.         return "ENGINE_CALLBACK_QUIT";

  315.     case ENGINE_CALLBACK_INLINE_DISPLAY_REDRAW:

  316.         return "ENGINE_CALLBACK_INLINE_DISPLAY_REDRAW";

  317.     case ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_ADDED:

  318.         return "ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_ADDED";

  319.     case ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_REMOVED:

  320.         return "ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_REMOVED";

  321.     case ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_CHANGED:

  322.         return "ENGINE_CALLBACK_PATCHBAY_PORT_GROUP_CHANGED";

  323.     case ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED:

  324.         return "ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED";

  325.     case ENGINE_CALLBACK_PATCHBAY_CLIENT_POSITION_CHANGED:

  326.         return "ENGINE_CALLBACK_PATCHBAY_CLIENT_POSITION_CHANGED";

  327.     case ENGINE_CALLBACK_EMBED_UI_RESIZED:

  328.         return "ENGINE_CALLBACK_EMBED_UI_RESIZED";

  329.     }

  330. 

  331.     carla_stderr("CarlaBackend::EngineCallbackOpcode2Str(%i) - invalid opcode", opcode);

  332.     return "";

  333. }

  334. 

  335. static inline

  336. const char* EngineOption2Str(const EngineOption option) noexcept

  337. {

  338.     switch (option)

  339.     {

  340.     case ENGINE_OPTION_DEBUG:

  341.         return "ENGINE_OPTION_DEBUG";

  342.     case ENGINE_OPTION_PROCESS_MODE:

  343.         return "ENGINE_OPTION_PROCESS_MODE";

  344.     case ENGINE_OPTION_TRANSPORT_MODE:

  345.         return "ENGINE_OPTION_TRANSPORT_MODE";

  346.     case ENGINE_OPTION_FORCE_STEREO:

  347.         return "ENGINE_OPTION_FORCE_STEREO";

  348.     case ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  349.         return "ENGINE_OPTION_PREFER_PLUGIN_BRIDGES";

  350.     case ENGINE_OPTION_PREFER_UI_BRIDGES:

  351.         return "ENGINE_OPTION_PREFER_UI_BRIDGES";

  352.     case ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

  353.         return "ENGINE_OPTION_UIS_ALWAYS_ON_TOP";

  354.     case ENGINE_OPTION_MAX_PARAMETERS:

  355.         return "ENGINE_OPTION_MAX_PARAMETERS";

  356.     case ENGINE_OPTION_RESET_XRUNS:

  357.         return "ENGINE_OPTION_RESET_XRUNS";

  358.     case ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  359.         return "ENGINE_OPTION_UI_BRIDGES_TIMEOUT";

  360.     case ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  361.         return "ENGINE_OPTION_AUDIO_BUFFER_SIZE";

  362.     case ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  363.         return "ENGINE_OPTION_AUDIO_SAMPLE_RATE";

  364.     case ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  365.         return "ENGINE_OPTION_AUDIO_TRIPLE_BUFFER";

  366.     case ENGINE_OPTION_AUDIO_DRIVER:

  367.         return "ENGINE_OPTION_AUDIO_DRIVER";

  368.     case ENGINE_OPTION_AUDIO_DEVICE:

  369.         return "ENGINE_OPTION_AUDIO_DEVICE";

  370. #ifndef BUILD_BRIDGE

  371.     case ENGINE_OPTION_OSC_ENABLED:

  372.         return "ENGINE_OPTION_OSC_ENABLED";

  373.     case ENGINE_OPTION_OSC_PORT_UDP:

  374.         return "ENGINE_OPTION_OSC_PORT_UDP";

  375.     case ENGINE_OPTION_OSC_PORT_TCP:

  376.         return "ENGINE_OPTION_OSC_PORT_TCP";

  377. #endif

  378.     case ENGINE_OPTION_FILE_PATH:

  379.         return "ENGINE_OPTION_FILE_PATH";

  380.     case ENGINE_OPTION_PLUGIN_PATH:

  381.         return "ENGINE_OPTION_PLUGIN_PATH";

  382.     case ENGINE_OPTION_PATH_BINARIES:

  383.         return "ENGINE_OPTION_PATH_BINARIES";

  384.     case ENGINE_OPTION_PATH_RESOURCES:

  385.         return "ENGINE_OPTION_PATH_RESOURCES";

  386.     case ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

  387.         return "ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR";

  388.     case ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

  389.         return "ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR";

  390.     case ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

  391.         return "ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR";

  392.     case ENGINE_OPTION_FRONTEND_UI_SCALE:

  393.         return "ENGINE_OPTION_FRONTEND_UI_SCALE";

  394.     case ENGINE_OPTION_FRONTEND_WIN_ID:

  395.         return "ENGINE_OPTION_FRONTEND_WIN_ID";

  396. #if !defined(BUILD_BRIDGE_ALTERNATIVE_ARCH) && !defined(CARLA_OS_WIN)

  397.     case ENGINE_OPTION_WINE_EXECUTABLE:

  398.         return "ENGINE_OPTION_WINE_EXECUTABLE";

  399.     case ENGINE_OPTION_WINE_AUTO_PREFIX:

  400.         return "ENGINE_OPTION_WINE_AUTO_PREFIX";

  401.     case ENGINE_OPTION_WINE_FALLBACK_PREFIX:

  402.         return "ENGINE_OPTION_WINE_FALLBACK_PREFIX";

  403.     case ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

  404.         return "ENGINE_OPTION_WINE_RT_PRIO_ENABLED";

  405.     case ENGINE_OPTION_WINE_BASE_RT_PRIO:

  406.         return "ENGINE_OPTION_WINE_BASE_RT_PRIO";

  407.     case ENGINE_OPTION_WINE_SERVER_RT_PRIO:

  408.         return "ENGINE_OPTION_WINE_SERVER_RT_PRIO";

  409. #endif

  410. #ifndef BUILD_BRIDGE

  411.     case ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  412.         return "ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT";

  413. #endif

  414.     case ENGINE_OPTION_CLIENT_NAME_PREFIX:

  415.         return "ENGINE_OPTION_CLIENT_NAME_PREFIX";

  416.     case ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

  417.         return "ENGINE_OPTION_PLUGINS_ARE_STANDALONE";

  418.     }

  419. 

  420.     carla_stderr("CarlaBackend::EngineOption2Str(%i) - invalid option", option);

  421.     return "";

  422. }

  423. 

  424. static inline

  425. const char* EngineProcessMode2Str(const EngineProcessMode mode) noexcept

  426. {

  427.     switch (mode)

  428.     {

  429.     case ENGINE_PROCESS_MODE_SINGLE_CLIENT:

  430.         return "ENGINE_PROCESS_MODE_SINGLE_CLIENT";

  431.     case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:

  432.         return "ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS";

  433.     case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:

  434.         return "ENGINE_PROCESS_MODE_CONTINUOUS_RACK";

  435.     case ENGINE_PROCESS_MODE_PATCHBAY:

  436.         return "ENGINE_PROCESS_MODE_PATCHBAY";

  437.     case ENGINE_PROCESS_MODE_BRIDGE:

  438.         return "ENGINE_PROCESS_MODE_BRIDGE";

  439.     }

  440. 

  441.     carla_stderr("CarlaBackend::EngineProcessMode2Str(%i) - invalid mode", mode);

  442.     return "";

  443. }

  444. 

  445. static inline

  446. const char* EngineTransportMode2Str(const EngineTransportMode mode) noexcept

  447. {

  448.     switch (mode)

  449.     {

  450.     case ENGINE_TRANSPORT_MODE_DISABLED:

  451.         return "ENGINE_TRANSPORT_MODE_DISABLED";

  452.     case ENGINE_TRANSPORT_MODE_INTERNAL:

  453.         return "ENGINE_TRANSPORT_MODE_INTERNAL";

  454.     case ENGINE_TRANSPORT_MODE_JACK:

  455.         return "ENGINE_TRANSPORT_MODE_JACK";

  456.     case ENGINE_TRANSPORT_MODE_PLUGIN:

  457.         return "ENGINE_TRANSPORT_MODE_PLUGIN";

  458.     case ENGINE_TRANSPORT_MODE_BRIDGE:

  459.         return "ENGINE_TRANSPORT_MODE_BRIDGE";

  460.     }

  461. 

  462.     carla_stderr("CarlaBackend::EngineTransportMode2Str(%i) - invalid mode", mode);

  463.     return "";

  464. }

  465. 

  466. static inline

  467. const char* FileCallbackOpcode2Str(const FileCallbackOpcode opcode) noexcept

  468. {

  469.     switch (opcode)

  470.     {

  471.     case FILE_CALLBACK_DEBUG:

  472.         return "FILE_CALLBACK_DEBUG";

  473.     case FILE_CALLBACK_OPEN:

  474.         return "FILE_CALLBACK_OPEN";

  475.     case FILE_CALLBACK_SAVE:

  476.         return "FILE_CALLBACK_SAVE";

  477.     }

  478. 

  479.     carla_stderr("CarlaBackend::FileCallbackOpcode2Str(%i) - invalid opcode", opcode);

  480.     return "";

  481. }

  482. 

  483. static inline

  484. const char* PatchbayIcon2Str(const PatchbayIcon icon) noexcept

  485. {

  486.     switch (icon)

  487.     {

  488.     case PATCHBAY_ICON_APPLICATION:

  489.         return "PATCHBAY_ICON_APPLICATION";

  490.     case PATCHBAY_ICON_PLUGIN:

  491.         return "PATCHBAY_ICON_PLUGIN";

  492.     case PATCHBAY_ICON_HARDWARE:

  493.         return "PATCHBAY_ICON_HARDWARE";

  494.     case PATCHBAY_ICON_CARLA:

  495.         return "PATCHBAY_ICON_CARLA";

  496.     case PATCHBAY_ICON_DISTRHO:

  497.         return "PATCHBAY_ICON_DISTRHO";

  498.     case PATCHBAY_ICON_FILE:

  499.         return "PATCHBAY_ICON_FILE";

  500.     }

  501. 

  502.     carla_stderr("CarlaBackend::PatchbayIcon2Str(%i) - invalid icon", icon);

  503.     return "";

  504. }

  505. 

  506. // -----------------------------------------------------------------------

  507. 

  508. static inline

  509. const char* NativePluginDispatcherOpcode2Str(const NativePluginDispatcherOpcode opcode) noexcept

  510. {

  511.     switch (opcode)

  512.     {

  513.     case NATIVE_PLUGIN_OPCODE_NULL:

  514.         return "NATIVE_PLUGIN_OPCODE_NULL";

  515.     case NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED:

  516.         return "NATIVE_PLUGIN_OPCODE_BUFFER_SIZE_CHANGED";

  517.     case NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED:

  518.         return "NATIVE_PLUGIN_OPCODE_SAMPLE_RATE_CHANGED";

  519.     case NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED:

  520.         return "NATIVE_PLUGIN_OPCODE_OFFLINE_CHANGED";

  521.     case NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED:

  522.         return "NATIVE_PLUGIN_OPCODE_UI_NAME_CHANGED";

  523.     case NATIVE_PLUGIN_OPCODE_GET_INTERNAL_HANDLE:

  524.         return "NATIVE_PLUGIN_OPCODE_GET_INTERNAL_HANDLE";

  525.     case NATIVE_PLUGIN_OPCODE_IDLE:

  526.         return "NATIVE_PLUGIN_OPCODE_IDLE";

  527.     case NATIVE_PLUGIN_OPCODE_UI_MIDI_EVENT:

  528.         return "NATIVE_PLUGIN_OPCODE_UI_MIDI_EVENT";

  529.     case NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED:

  530.         return "NATIVE_PLUGIN_OPCODE_HOST_USES_EMBED";

  531.     case NATIVE_PLUGIN_OPCODE_HOST_OPTION:

  532.         return "NATIVE_PLUGIN_OPCODE_HOST_OPTION";

  533.     }

  534. 

  535.     carla_stderr("CarlaBackend::NativePluginDispatcherOpcode2Str(%i) - invalid icon", opcode);

  536.     return "";

  537. }

  538. 

  539. static inline

  540. const char* NativeHostDispatcherOpcode2Str(const NativeHostDispatcherOpcode opcode) noexcept

  541. {

  542.     switch (opcode)

  543.     {

  544.     case NATIVE_HOST_OPCODE_NULL:

  545.         return "NATIVE_HOST_OPCODE_NULL";

  546.     case NATIVE_HOST_OPCODE_UPDATE_PARAMETER:

  547.         return "NATIVE_HOST_OPCODE_UPDATE_PARAMETER";

  548.     case NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM:

  549.         return "NATIVE_HOST_OPCODE_UPDATE_MIDI_PROGRAM";

  550.     case NATIVE_HOST_OPCODE_RELOAD_PARAMETERS:

  551.         return "NATIVE_HOST_OPCODE_RELOAD_PARAMETERS";

  552.     case NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS:

  553.         return "NATIVE_HOST_OPCODE_RELOAD_MIDI_PROGRAMS";

  554.     case NATIVE_HOST_OPCODE_RELOAD_ALL:

  555.         return "NATIVE_HOST_OPCODE_RELOAD_ALL";

  556.     case NATIVE_HOST_OPCODE_UI_UNAVAILABLE:

  557.         return "NATIVE_HOST_OPCODE_UI_UNAVAILABLE";

  558.     case NATIVE_HOST_OPCODE_HOST_IDLE:

  559.         return "NATIVE_HOST_OPCODE_HOST_IDLE";

  560.     case NATIVE_HOST_OPCODE_INTERNAL_PLUGIN:

  561.         return "NATIVE_HOST_OPCODE_INTERNAL_PLUGIN";

  562.     case NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY:

  563.         return "NATIVE_HOST_OPCODE_QUEUE_INLINE_DISPLAY";

  564.     case NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER:

  565.         return "NATIVE_HOST_OPCODE_UI_TOUCH_PARAMETER";

  566.     case NATIVE_HOST_OPCODE_REQUEST_IDLE:

  567.         return "NATIVE_HOST_OPCODE_REQUEST_IDLE";

  568.     case NATIVE_HOST_OPCODE_GET_FILE_PATH:

  569.         return "NATIVE_HOST_OPCODE_GET_FILE_PATH";

  570.     case NATIVE_HOST_OPCODE_UI_RESIZE:

  571.         return "NATIVE_HOST_OPCODE_UI_RESIZE";

  572.     case NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA:

  573.         return "NATIVE_HOST_OPCODE_PREVIEW_BUFFER_DATA";

  574.     }

  575. 

  576.     carla_stderr("CarlaBackend::NativeHostDispatcherOpcode2Str(%i) - invalid icon", opcode);

  577.     return "";

  578. }

  579. 

  580. // -----------------------------------------------------------------------

  581. 

  582. static inline

  583. const char* getBinaryTypeAsString(const BinaryType type) noexcept

  584. {

  585.     carla_debug("CarlaBackend::getBinaryTypeAsString(%i:%s)", type, BinaryType2Str(type));

  586. 

  587.     if (type == BINARY_NATIVE)

  588.         return "native";

  589. 

  590.     switch (type)

  591.     {

  592.     case BINARY_NONE:

  593.         return "none";

  594.     case BINARY_POSIX32:

  595.         return "posix32";

  596.     case BINARY_POSIX64:

  597.         return "posix64";

  598.     case BINARY_WIN32:

  599.         return "win32";

  600.     case BINARY_WIN64:

  601.         return "win64";

  602.     case BINARY_OTHER:

  603.         return "other";

  604.     }

  605. 

  606.     carla_stderr("CarlaBackend::getBinaryTypeAsString(%i) - invalid type", type);

  607.     return "NONE";

  608. }

  609. 

  610. static inline

  611. BinaryType getBinaryTypeFromString(const char* const ctype) noexcept

  612. {

  613.     CARLA_SAFE_ASSERT_RETURN(ctype != nullptr && ctype[0] != '\0', BINARY_NONE);

  614.     carla_debug("CarlaBackend::getBinaryTypeFromString(\"%s\")", ctype);

  615. 

  616.     CarlaString stype(ctype);

  617. 

  618.     if (stype.isEmpty())

  619.         return BINARY_NONE;

  620. 

  621.     stype.toLower();

  622. 

  623.     if (stype == "none")

  624.         return BINARY_NONE;

  625.     if (stype == "native")

  626.         return BINARY_NATIVE;

  627.     if (stype == "posix32" || stype == "linux32" || stype == "mac32")

  628.         return BINARY_POSIX32;

  629.     if (stype == "posix64" || stype == "linux64" || stype == "mac64")

  630.         return BINARY_POSIX64;

  631.     if (stype == "win32")

  632.         return BINARY_WIN32;

  633.     if (stype == "win64")

  634.         return BINARY_WIN64;

  635.     if (stype == "other")

  636.         return BINARY_OTHER;

  637. 

  638.     carla_stderr("CarlaBackend::getBinaryTypeFromString(\"%s\") - invalid string type", ctype);

  639.     return BINARY_NONE;

  640. }

  641. 

  642. // -----------------------------------------------------------------------

  643. 

  644. static inline

  645. const char* getPluginCategoryAsString(const PluginCategory category) noexcept

  646. {

  647.     carla_debug("CarlaBackend::getPluginCategoryAsString(%i:%s)", category, PluginCategory2Str(category));

  648. 

  649.     switch (category)

  650.     {

  651.     case PLUGIN_CATEGORY_NONE:

  652.         return "none";

  653.     case PLUGIN_CATEGORY_SYNTH:

  654.         return "synth";

  655.     case PLUGIN_CATEGORY_DELAY:

  656.         return "delay";

  657.     case PLUGIN_CATEGORY_EQ:

  658.         return "eq";

  659.     case PLUGIN_CATEGORY_FILTER:

  660.         return "filter";

  661.     case PLUGIN_CATEGORY_DISTORTION:

  662.         return "distortion";

  663.     case PLUGIN_CATEGORY_DYNAMICS:

  664.         return "dynamics";

  665.     case PLUGIN_CATEGORY_MODULATOR:

  666.         return "modulator";

  667.     case PLUGIN_CATEGORY_UTILITY:

  668.         return "utility";

  669.     case PLUGIN_CATEGORY_OTHER:

  670.         return "other";

  671.     }

  672. 

  673.     carla_stderr("CarlaBackend::getPluginCategoryAsString(%i) - invalid category", category);

  674.     return "NONE";

  675. }

  676. 

  677. static inline

  678. PluginCategory getPluginCategoryFromString(const char* const category) noexcept

  679. {

  680.     CARLA_SAFE_ASSERT_RETURN(category != nullptr && category[0] != '\0', PLUGIN_CATEGORY_NONE);

  681.     carla_debug("CarlaBackend::getPluginCategoryFromString(\"%s\")", category);

  682. 

  683.     if (std::strcmp(category, "none") == 0)

  684.         return PLUGIN_CATEGORY_NONE;

  685.     if (std::strcmp(category, "synth") == 0)

  686.         return PLUGIN_CATEGORY_SYNTH;

  687.     if (std::strcmp(category, "delay") == 0)

  688.         return PLUGIN_CATEGORY_DELAY;

  689.     if (std::strcmp(category, "eq") == 0)

  690.         return PLUGIN_CATEGORY_EQ;

  691.     if (std::strcmp(category, "filter") == 0)

  692.         return PLUGIN_CATEGORY_FILTER;

  693.     if (std::strcmp(category, "distortion") == 0)

  694.         return PLUGIN_CATEGORY_DISTORTION;

  695.     if (std::strcmp(category, "dynamics") == 0)

  696.         return PLUGIN_CATEGORY_DYNAMICS;

  697.     if (std::strcmp(category, "modulator") == 0)

  698.         return PLUGIN_CATEGORY_MODULATOR;

  699.     if (std::strcmp(category, "utility") == 0)

  700.         return PLUGIN_CATEGORY_UTILITY;

  701.     if (std::strcmp(category, "other") == 0)

  702.         return PLUGIN_CATEGORY_OTHER;

  703. 

  704.     carla_stderr("CarlaBackend::getPluginCategoryFromString(\"%s\") - invalid category", category);

  705.     return PLUGIN_CATEGORY_NONE;

  706. }

  707. 

  708. // -----------------------------------------------------------------------

  709. 

  710. static inline

  711. const char* getPluginTypeAsString(const PluginType type) noexcept

  712. {

  713.     carla_debug("CarlaBackend::getPluginTypeAsString(%i:%s)", type, PluginType2Str(type));

  714. 

  715.     switch (type)

  716.     {

  717.     case PLUGIN_NONE:

  718.         return "NONE";

  719.     case PLUGIN_INTERNAL:

  720.         return "INTERNAL";

  721.     case PLUGIN_LADSPA:

  722.         return "LADSPA";

  723.     case PLUGIN_DSSI:

  724.         return "DSSI";

  725.     case PLUGIN_LV2:

  726.         return "LV2";

  727.     case PLUGIN_VST2:

  728.         return "VST2";

  729.     case PLUGIN_VST3:

  730.         return "VST3";

  731.     case PLUGIN_AU:

  732.         return "AU";

  733.     case PLUGIN_DLS:

  734.         return "DLS";

  735.     case PLUGIN_GIG:

  736.         return "GIG";

  737.     case PLUGIN_SF2:

  738.         return "SF2";

  739.     case PLUGIN_SFZ:

  740.         return "SFZ";

  741.     case PLUGIN_JACK:

  742.         return "JACK";

  743.     case PLUGIN_JSFX:

  744.         return "JSFX";

  745.     case PLUGIN_CLAP:

  746.         return "CLAP";

  747.     case PLUGIN_TYPE_COUNT:

  748.         break;

  749.     }

  750. 

  751.     carla_stderr("CarlaBackend::getPluginTypeAsString(%i) - invalid type", type);

  752.     return "NONE";

  753. }

  754. 

  755. static inline

  756. PluginType getPluginTypeFromString(const char* const ctype) noexcept

  757. {

  758.     CARLA_SAFE_ASSERT_RETURN(ctype != nullptr && ctype[0] != '\0', PLUGIN_NONE);

  759.     carla_debug("CarlaBackend::getPluginTypeFromString(\"%s\")", ctype);

  760. 

  761.     CarlaString stype(ctype);

  762. 

  763.     if (stype.isEmpty())

  764.         return PLUGIN_NONE;

  765. 

  766.     stype.toLower();

  767. 

  768.     if (stype == "none")

  769.         return PLUGIN_NONE;

  770.     if (stype == "internal" || stype == "native")

  771.         return PLUGIN_INTERNAL;

  772.     if (stype == "ladspa")

  773.         return PLUGIN_LADSPA;

  774.     if (stype == "dssi")

  775.         return PLUGIN_DSSI;

  776.     if (stype == "lv2")

  777.         return PLUGIN_LV2;

  778.     if (stype == "vst2" || stype == "vst")

  779.         return PLUGIN_VST2;

  780.     if (stype == "vst3")

  781.         return PLUGIN_VST3;

  782.     if (stype == "au" || stype == "audiounit")

  783.         return PLUGIN_AU;

  784.     if (stype == "dls")

  785.         return PLUGIN_DLS;

  786.     if (stype == "gig")

  787.         return PLUGIN_GIG;

  788.     if (stype == "sf2" || stype == "sf3")

  789.         return PLUGIN_SF2;

  790.     if (stype == "sfz")

  791.         return PLUGIN_SFZ;

  792.     if (stype == "jack")

  793.         return PLUGIN_JACK;

  794.     if (stype == "jsfx")

  795.         return PLUGIN_JSFX;

  796.     if (stype == "clap")

  797.         return PLUGIN_CLAP;

  798. 

  799.     carla_stderr("CarlaBackend::getPluginTypeFromString(\"%s\") - invalid string type", ctype);

  800.     return PLUGIN_NONE;

  801. }

  802. 

  803. // -----------------------------------------------------------------------

  804. 

  805. static inline

  806. PluginCategory getPluginCategoryFromName(const char* const name) noexcept

  807. {

  808.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', PLUGIN_CATEGORY_NONE);

  809.     carla_debug("CarlaBackend::getPluginCategoryFromName(\"%s\")", name);

  810. 

  811.     CarlaString sname(name);

  812. 

  813.     if (sname.isEmpty())

  814.         return PLUGIN_CATEGORY_NONE;

  815. 

  816.     sname.toLower();

  817. 

  818.     // generic tags first

  819.     if (sname.contains("delay"))

  820.         return PLUGIN_CATEGORY_DELAY;

  821.     if (sname.contains("reverb"))

  822.         return PLUGIN_CATEGORY_DELAY;

  823. 

  824.     // filter

  825.     if (sname.contains("filter"))

  826.         return PLUGIN_CATEGORY_FILTER;

  827. 

  828.     // distortion

  829.     if (sname.contains("distortion"))

  830.         return PLUGIN_CATEGORY_DISTORTION;

  831. 

  832.     // dynamics

  833.     if (sname.contains("dynamics"))

  834.         return PLUGIN_CATEGORY_DYNAMICS;

  835.     if (sname.contains("amplifier"))

  836.         return PLUGIN_CATEGORY_DYNAMICS;

  837.     if (sname.contains("compressor"))

  838.         return PLUGIN_CATEGORY_DYNAMICS;

  839.     if (sname.contains("enhancer"))

  840.         return PLUGIN_CATEGORY_DYNAMICS;

  841.     if (sname.contains("exciter"))

  842.         return PLUGIN_CATEGORY_DYNAMICS;

  843.     if (sname.contains("gate"))

  844.         return PLUGIN_CATEGORY_DYNAMICS;

  845.     if (sname.contains("limiter"))

  846.         return PLUGIN_CATEGORY_DYNAMICS;

  847. 

  848.     // modulator

  849.     if (sname.contains("modulator"))

  850.         return PLUGIN_CATEGORY_MODULATOR;

  851.     if (sname.contains("chorus"))

  852.         return PLUGIN_CATEGORY_MODULATOR;

  853.     if (sname.contains("flanger"))

  854.         return PLUGIN_CATEGORY_MODULATOR;

  855.     if (sname.contains("phaser"))

  856.         return PLUGIN_CATEGORY_MODULATOR;

  857.     if (sname.contains("saturator"))

  858.         return PLUGIN_CATEGORY_MODULATOR;

  859. 

  860.     // utility

  861.     if (sname.contains("utility"))

  862.         return PLUGIN_CATEGORY_UTILITY;

  863.     if (sname.contains("analyzer"))

  864.         return PLUGIN_CATEGORY_UTILITY;

  865.     if (sname.contains("converter"))

  866.         return PLUGIN_CATEGORY_UTILITY;

  867.     if (sname.contains("deesser"))

  868.         return PLUGIN_CATEGORY_UTILITY;

  869.     if (sname.contains("mixer"))

  870.         return PLUGIN_CATEGORY_UTILITY;

  871. 

  872.     // common tags

  873.     if (sname.contains("verb"))

  874.         return PLUGIN_CATEGORY_DELAY;

  875. 

  876.     if (sname.contains("eq"))

  877.         return PLUGIN_CATEGORY_EQ;

  878. 

  879.     if (sname.contains("tool"))

  880.         return PLUGIN_CATEGORY_UTILITY;

  881. 

  882.     // synth

  883.     if (sname.contains("synth"))

  884.         return PLUGIN_CATEGORY_SYNTH;

  885. 

  886.     // other

  887.     if (sname.contains("misc"))

  888.         return PLUGIN_CATEGORY_OTHER;

  889.     if (sname.contains("other"))

  890.         return PLUGIN_CATEGORY_OTHER;

  891. 

  892.     return PLUGIN_CATEGORY_NONE;

  893. }

  894. 

  895. // -----------------------------------------------------------------------

  896. 

  897. static inline

  898. bool isPluginOptionEnabled(const uint options, const uint option)

  899. {

  900.     if (options == PLUGIN_OPTIONS_NULL)

  901.         return true;

  902.     if (options & option)

  903.         return true;

  904.     return false;

  905. }

  906. 

  907. static inline

  908. bool isPluginOptionInverseEnabled(const uint options, const uint option)

  909. {

  910.     if (options == PLUGIN_OPTIONS_NULL)

  911.         return false;

  912.     if (options & option)

  913.         return true;

  914.     return false;

  915. }

  916. 

  917. // -----------------------------------------------------------------------

  918. 

  919. CARLA_BACKEND_END_NAMESPACE

  920. 

  921. #endif // CARLA_BACKEND_UTILS_HPP_INCLUDED