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.
6480 Commits
16 Branches
14GB
Tree: 6646cc4c7c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6646cc4c7c'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2409 lines
86KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2022 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. // TODO:

  19. // Check carla_stderr2("Engine is not running"); <= prepend func name and args

  20. 

  21. #include "CarlaHostImpl.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngineInit.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #include "water/files/File.h"

  32. 

  33. #ifdef USING_JUCE

  34. # include "carla_juce/carla_juce.h"

  35. #endif

  36. 

  37. #define CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(cond, msg, ret) \

  38.     if (! (cond)) {                                              \

  39.         carla_stderr2("%s: " msg, __FUNCTION__);                 \

  40.         if (handle->isStandalone)                                \

  41.             ((CarlaHostStandalone*)handle)->lastError = msg;     \

  42.         return ret;                                              \

  43.     }

  44. 

  45. // -------------------------------------------------------------------------------------------------------------------

  46. // Always return a valid string ptr for standalone functions

  47. 

  48. static const char* const gNullCharPtr = "";

  49. 

  50. static void checkStringPtr(const char*& charPtr) noexcept

  51. {

  52.     if (charPtr == nullptr)

  53.         charPtr = gNullCharPtr;

  54. }

  55. 

  56. // -------------------------------------------------------------------------------------------------------------------

  57. // Constructors

  58. 

  59. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  60.     : type(CB::PLUGIN_NONE),

  61.       category(CB::PLUGIN_CATEGORY_NONE),

  62.       hints(0x0),

  63.       optionsAvailable(0x0),

  64.       optionsEnabled(0x0),

  65.       filename(gNullCharPtr),

  66.       name(gNullCharPtr),

  67.       label(gNullCharPtr),

  68.       maker(gNullCharPtr),

  69.       copyright(gNullCharPtr),

  70.       iconName(gNullCharPtr),

  71.       uniqueId(0) {}

  72. 

  73. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  74. {

  75.     if (label != gNullCharPtr)

  76.         delete[] label;

  77.     if (maker != gNullCharPtr)

  78.         delete[] maker;

  79.     if (copyright != gNullCharPtr)

  80.         delete[] copyright;

  81. }

  82. 

  83. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  84.     : name(gNullCharPtr),

  85.       symbol(gNullCharPtr),

  86.       unit(gNullCharPtr),

  87.       comment(gNullCharPtr),

  88.       groupName(gNullCharPtr),

  89.       scalePointCount(0) {}

  90. 

  91. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  92. {

  93.     if (name != gNullCharPtr)

  94.         delete[] name;

  95.     if (symbol != gNullCharPtr)

  96.         delete[] symbol;

  97.     if (unit != gNullCharPtr)

  98.         delete[] unit;

  99.     if (comment != gNullCharPtr)

  100.         delete[] comment;

  101.     if (groupName != gNullCharPtr)

  102.         delete[] groupName;

  103. }

  104. 

  105. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  106.     : value(0.0f),

  107.       label(gNullCharPtr) {}

  108. 

  109. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  110. {

  111.     if (label != gNullCharPtr)

  112.         delete[] label;

  113. }

  114. 

  115. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  116.     : playing(false),

  117.       frame(0),

  118.       bar(0),

  119.       beat(0),

  120.       tick(0),

  121.       bpm(0.0) {}

  122. 

  123. void _CarlaTransportInfo::clear() noexcept

  124. {

  125.     playing = false;

  126.     frame = 0;

  127.     bar = 0;

  128.     beat = 0;

  129.     tick = 0;

  130.     bpm = 0.0;

  131. }

  132. 

  133. // --------------------------------------------------------------------------------------------------------------------

  134. 

  135. using CARLA_BACKEND_NAMESPACE::CarlaPluginPtr;

  136. 

  137. // --------------------------------------------------------------------------------------------------------------------

  138. 

  139. uint carla_get_engine_driver_count()

  140. {

  141.     carla_debug("carla_get_engine_driver_count()");

  142. 

  143.     return CarlaEngine::getDriverCount();

  144. }

  145. 

  146. const char* carla_get_engine_driver_name(uint index)

  147. {

  148.     carla_debug("carla_get_engine_driver_name(%i)", index);

  149. 

  150.     return CarlaEngine::getDriverName(index);

  151. }

  152. 

  153. const char* const* carla_get_engine_driver_device_names(uint index)

  154. {

  155.     carla_debug("carla_get_engine_driver_device_names(%i)", index);

  156. 

  157.     return CarlaEngine::getDriverDeviceNames(index);

  158. }

  159. 

  160. const EngineDriverDeviceInfo* carla_get_engine_driver_device_info(uint index, const char* name)

  161. {

  162.     CARLA_SAFE_ASSERT_RETURN(name != nullptr, nullptr);

  163. 

  164.     static EngineDriverDeviceInfo retDevInfo;

  165.     static const uint32_t nullBufferSizes[] = { 0   };

  166.     static const double   nullSampleRates[] = { 0.0 };

  167. 

  168.     carla_debug("carla_get_engine_driver_device_info(%i, \"%s\")", index, name);

  169. 

  170.     if (const EngineDriverDeviceInfo* const devInfo = CarlaEngine::getDriverDeviceInfo(index, name))

  171.     {

  172.         retDevInfo.hints       =  devInfo->hints;

  173.         retDevInfo.bufferSizes = (devInfo->bufferSizes != nullptr) ? devInfo->bufferSizes : nullBufferSizes;

  174.         retDevInfo.sampleRates = (devInfo->sampleRates != nullptr) ? devInfo->sampleRates : nullSampleRates;

  175.     }

  176.     else

  177.     {

  178.         retDevInfo.hints       = 0x0;

  179.         retDevInfo.bufferSizes = nullBufferSizes;

  180.         retDevInfo.sampleRates = nullSampleRates;

  181.     }

  182. 

  183.     return &retDevInfo;

  184. }

  185. 

  186. bool carla_show_engine_driver_device_control_panel(uint index, const char* name)

  187. {

  188.     return CarlaEngine::showDriverDeviceControlPanel(index, name);

  189. }

  190. 

  191. // --------------------------------------------------------------------------------------------------------------------

  192. 

  193. CarlaHostHandle carla_standalone_host_init(void)

  194. {

  195. #ifdef CARLA_OS_UNIX

  196.     static const ThreadSafeFFTW sThreadSafeFFTW;

  197. #endif

  198. 

  199.     static CarlaHostStandalone gStandalone;

  200. 

  201.     return &gStandalone;

  202. }

  203. 

  204. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  205. {

  206.     carla_debug("carla_get_engine(%p)", handle);

  207. 

  208.     return handle->engine;

  209. }

  210. 

  211. // --------------------------------------------------------------------------------------------------------------------

  212. 

  213. static void carla_engine_init_common(const CarlaHostStandalone& standalone, CarlaEngine* const engine)

  214. {

  215.     engine->setCallback(standalone.engineCallback, standalone.engineCallbackPtr);

  216.     engine->setFileCallback(standalone.fileCallback, standalone.fileCallbackPtr);

  217. 

  218.     using water::File;

  219.     const File waterBinaryDir(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory());

  220. 

  221. #ifdef BUILD_BRIDGE

  222.     /*

  223.     if (const char* const forceStereo = std::getenv("ENGINE_OPTION_FORCE_STEREO"))

  224.         engine->setOption(CB::ENGINE_OPTION_FORCE_STEREO, (std::strcmp(forceStereo, "true") == 0) ? 1 : 0, nullptr);

  225. 

  226.     if (const char* const preferPluginBridges = std::getenv("ENGINE_OPTION_PREFER_PLUGIN_BRIDGES"))

  227.         engine->setOption(CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES, (std::strcmp(preferPluginBridges, "true") == 0) ? 1 : 0, nullptr);

  228. 

  229.     if (const char* const preferUiBridges = std::getenv("ENGINE_OPTION_PREFER_UI_BRIDGES"))

  230.         engine->setOption(CB::ENGINE_OPTION_PREFER_UI_BRIDGES, (std::strcmp(preferUiBridges, "true") == 0) ? 1 : 0, nullptr);

  231.     */

  232. 

  233.     if (const char* const uisAlwaysOnTop = std::getenv("ENGINE_OPTION_UIS_ALWAYS_ON_TOP"))

  234.         engine->setOption(CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP, (std::strcmp(uisAlwaysOnTop, "true") == 0) ? 1 : 0, nullptr);

  235. 

  236.     if (const char* const maxParameters = std::getenv("ENGINE_OPTION_MAX_PARAMETERS"))

  237.         engine->setOption(CB::ENGINE_OPTION_MAX_PARAMETERS, std::atoi(maxParameters), nullptr);

  238. 

  239.     if (const char* const resetXruns = std::getenv("ENGINE_OPTION_RESET_XRUNS"))

  240.         engine->setOption(CB::ENGINE_OPTION_RESET_XRUNS, (std::strcmp(resetXruns, "true") == 0) ? 1 : 0, nullptr);

  241. 

  242.     if (const char* const uiBridgesTimeout = std::getenv("ENGINE_OPTION_UI_BRIDGES_TIMEOUT"))

  243.         engine->setOption(CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT, std::atoi(uiBridgesTimeout), nullptr);

  244. 

  245.     if (const char* const pathAudio = std::getenv("ENGINE_OPTION_FILE_PATH_AUDIO"))

  246.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_AUDIO, pathAudio);

  247. 

  248.     if (const char* const pathMIDI = std::getenv("ENGINE_OPTION_FILE_PATH_MIDI"))

  249.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_MIDI, pathMIDI);

  250. 

  251.     if (const char* const pathLADSPA = std::getenv("ENGINE_OPTION_PLUGIN_PATH_LADSPA"))

  252.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_LADSPA, pathLADSPA);

  253. 

  254.     if (const char* const pathDSSI = std::getenv("ENGINE_OPTION_PLUGIN_PATH_DSSI"))

  255.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_DSSI, pathDSSI);

  256. 

  257.     if (const char* const pathLV2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_LV2"))

  258.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_LV2, pathLV2);

  259. 

  260.     if (const char* const pathVST2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST2"))

  261.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST2, pathVST2);

  262. 

  263.     if (const char* const pathVST3 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST3"))

  264.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST3, pathVST3);

  265. 

  266.     if (const char* const pathSF2 = std::getenv("ENGINE_OPTION_PLUGIN_PATH_SF2"))

  267.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_SF2, pathSF2);

  268. 

  269.     if (const char* const pathSFZ = std::getenv("ENGINE_OPTION_PLUGIN_PATH_SFZ"))

  270.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_SFZ, pathSFZ);

  271. 

  272.     if (const char* const pathJSFX = std::getenv("ENGINE_OPTION_PLUGIN_PATH_JSFX"))

  273.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_JSFX, pathJSFX);

  274. 

  275.     if (const char* const binaryDir = std::getenv("ENGINE_OPTION_PATH_BINARIES"))

  276.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES, 0, binaryDir);

  277.     else

  278.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES, 0, waterBinaryDir.getFullPathName().toRawUTF8());

  279. 

  280.     if (const char* const resourceDir = std::getenv("ENGINE_OPTION_PATH_RESOURCES"))

  281.         engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES, 0, resourceDir);

  282.     else

  283.         engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES, 0, waterBinaryDir.getChildFile("resources").getFullPathName().toRawUTF8());

  284. 

  285.     if (const char* const preventBadBehaviour = std::getenv("ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR"))

  286.         engine->setOption(CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR, (std::strcmp(preventBadBehaviour, "true") == 0) ? 1 : 0, nullptr);

  287. 

  288.     if (const char* const frontendWinId = std::getenv("ENGINE_OPTION_FRONTEND_WIN_ID"))

  289.         engine->setOption(CB::ENGINE_OPTION_FRONTEND_WIN_ID, 0, frontendWinId);

  290. #else

  291.     engine->setOption(CB::ENGINE_OPTION_FORCE_STEREO,          standalone.engineOptions.forceStereo         ? 1 : 0,        nullptr);

  292.     engine->setOption(CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES, standalone.engineOptions.preferPluginBridges ? 1 : 0,        nullptr);

  293.     engine->setOption(CB::ENGINE_OPTION_PREFER_UI_BRIDGES,     standalone.engineOptions.preferUiBridges     ? 1 : 0,        nullptr);

  294.     engine->setOption(CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP,     standalone.engineOptions.uisAlwaysOnTop      ? 1 : 0,        nullptr);

  295.     engine->setOption(CB::ENGINE_OPTION_MAX_PARAMETERS,        static_cast<int>(standalone.engineOptions.maxParameters),    nullptr);

  296.     engine->setOption(CB::ENGINE_OPTION_RESET_XRUNS,           standalone.engineOptions.resetXruns          ? 1 : 0,        nullptr);

  297.     engine->setOption(CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT,    static_cast<int>(standalone.engineOptions.uiBridgesTimeout), nullptr);

  298.     engine->setOption(CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE,     static_cast<int>(standalone.engineOptions.audioBufferSize),  nullptr);

  299.     engine->setOption(CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE,     static_cast<int>(standalone.engineOptions.audioSampleRate),  nullptr);

  300.     engine->setOption(CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER,   standalone.engineOptions.audioTripleBuffer   ? 1 : 0,        nullptr);

  301. 

  302.     if (standalone.engineOptions.audioDriver != nullptr)

  303.         engine->setOption(CB::ENGINE_OPTION_AUDIO_DRIVER,      0, standalone.engineOptions.audioDriver);

  304. 

  305.     if (standalone.engineOptions.audioDevice != nullptr)

  306.         engine->setOption(CB::ENGINE_OPTION_AUDIO_DEVICE,      0, standalone.engineOptions.audioDevice);

  307. 

  308.     engine->setOption(CB::ENGINE_OPTION_OSC_ENABLED,  standalone.engineOptions.oscEnabled, nullptr);

  309.     engine->setOption(CB::ENGINE_OPTION_OSC_PORT_TCP, standalone.engineOptions.oscPortTCP, nullptr);

  310.     engine->setOption(CB::ENGINE_OPTION_OSC_PORT_UDP, standalone.engineOptions.oscPortUDP, nullptr);

  311. 

  312.     if (standalone.engineOptions.pathAudio != nullptr)

  313.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_AUDIO, standalone.engineOptions.pathAudio);

  314. 

  315.     if (standalone.engineOptions.pathMIDI != nullptr)

  316.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_MIDI, standalone.engineOptions.pathMIDI);

  317. 

  318.     if (standalone.engineOptions.pathLADSPA != nullptr)

  319.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LADSPA, standalone.engineOptions.pathLADSPA);

  320. 

  321.     if (standalone.engineOptions.pathDSSI != nullptr)

  322.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_DSSI, standalone.engineOptions.pathDSSI);

  323. 

  324.     if (standalone.engineOptions.pathLV2 != nullptr)

  325.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LV2, standalone.engineOptions.pathLV2);

  326. 

  327.     if (standalone.engineOptions.pathVST2 != nullptr)

  328.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST2, standalone.engineOptions.pathVST2);

  329. 

  330.     if (standalone.engineOptions.pathVST3 != nullptr)

  331.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST3, standalone.engineOptions.pathVST3);

  332. 

  333.     if (standalone.engineOptions.pathSF2 != nullptr)

  334.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SF2, standalone.engineOptions.pathSF2);

  335. 

  336.     if (standalone.engineOptions.pathSFZ != nullptr)

  337.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SFZ, standalone.engineOptions.pathSFZ);

  338. 

  339.     if (standalone.engineOptions.pathJSFX != nullptr)

  340.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_JSFX, standalone.engineOptions.pathJSFX);

  341. 

  342.     if (standalone.engineOptions.binaryDir != nullptr && standalone.engineOptions.binaryDir[0] != '\0')

  343.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES, 0, standalone.engineOptions.binaryDir);

  344.     else

  345.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES, 0, waterBinaryDir.getFullPathName().toRawUTF8());

  346. 

  347.     if (standalone.engineOptions.resourceDir != nullptr && standalone.engineOptions.resourceDir[0] != '\0')

  348.         engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,    0, standalone.engineOptions.resourceDir);

  349. 

  350.     engine->setOption(CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR,    standalone.engineOptions.preventBadBehaviour ? 1 : 0,  nullptr);

  351. 

  352.     engine->setOption(CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR, static_cast<int>(standalone.engineOptions.bgColor), nullptr);

  353.     engine->setOption(CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR, static_cast<int>(standalone.engineOptions.fgColor), nullptr);

  354.     engine->setOption(CB::ENGINE_OPTION_FRONTEND_UI_SCALE, static_cast<int>(standalone.engineOptions.uiScale * 1000.0f), nullptr);

  355. 

  356.     if (standalone.engineOptions.frontendWinId != 0)

  357.     {

  358.         char strBuf[STR_MAX+1];

  359.         strBuf[STR_MAX] = '\0';

  360.         std::snprintf(strBuf, STR_MAX, P_UINTPTR, standalone.engineOptions.frontendWinId);

  361.         engine->setOption(CB::ENGINE_OPTION_FRONTEND_WIN_ID, 0, strBuf);

  362.     }

  363.     else

  364.     {

  365.         engine->setOption(CB::ENGINE_OPTION_FRONTEND_WIN_ID, 0, "0");

  366.     }

  367. 

  368. # ifndef CARLA_OS_WIN

  369.     if (standalone.engineOptions.wine.executable != nullptr && standalone.engineOptions.wine.executable[0] != '\0')

  370.         engine->setOption(CB::ENGINE_OPTION_WINE_EXECUTABLE, 0, standalone.engineOptions.wine.executable);

  371. 

  372.     engine->setOption(CB::ENGINE_OPTION_WINE_AUTO_PREFIX, standalone.engineOptions.wine.autoPrefix ? 1 : 0, nullptr);

  373. 

  374.     if (standalone.engineOptions.wine.fallbackPrefix != nullptr && standalone.engineOptions.wine.fallbackPrefix[0] != '\0')

  375.         engine->setOption(CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX, 0, standalone.engineOptions.wine.fallbackPrefix);

  376. 

  377.     engine->setOption(CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED, standalone.engineOptions.wine.rtPrio ? 1 : 0, nullptr);

  378.     engine->setOption(CB::ENGINE_OPTION_WINE_BASE_RT_PRIO, standalone.engineOptions.wine.baseRtPrio, nullptr);

  379.     engine->setOption(CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO, standalone.engineOptions.wine.serverRtPrio, nullptr);

  380. # endif

  381. 

  382.     engine->setOption(CB::ENGINE_OPTION_CLIENT_NAME_PREFIX, 0, standalone.engineOptions.clientNamePrefix);

  383. 

  384.     engine->setOption(CB::ENGINE_OPTION_PLUGINS_ARE_STANDALONE, standalone.engineOptions.pluginsAreStandalone, nullptr);

  385. #endif // BUILD_BRIDGE

  386. }

  387. 

  388. bool carla_engine_init(CarlaHostHandle handle, const char* driverName, const char* clientName)

  389. {

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

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

  392.     carla_debug("carla_engine_init(%p, \"%s\", \"%s\")", handle, driverName, clientName);

  393. 

  394.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->isStandalone, "Must be a standalone host handle", false);

  395.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine == nullptr, "Engine is already initialized", false);

  396. 

  397. #ifdef CARLA_OS_WIN

  398.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  399. #endif

  400. 

  401. #ifdef USING_JUCE

  402.     CarlaJUCE::initialiseJuce_GUI();

  403. #endif

  404. 

  405.     CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  406. 

  407.     CarlaEngine* const engine = CarlaEngine::newDriverByName(driverName);

  408.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(engine != nullptr, "The selected audio driver is not available", false);

  409. 

  410.     shandle.engine = engine;

  411. 

  412. #ifdef BUILD_BRIDGE

  413.     if (std::getenv("CARLA_BRIDGE_DUMMY") != nullptr)

  414.     {

  415.         // engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,      CB::ENGINE_PROCESS_MODE_PATCHBAY,         nullptr);

  416.         engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,      CB::ENGINE_PROCESS_MODE_CONTINUOUS_RACK,  nullptr);

  417.         engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE,    CB::ENGINE_TRANSPORT_MODE_INTERNAL,       nullptr);

  418. 

  419.         engine->setOption(CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE, 4096, nullptr);

  420.         engine->setOption(CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE, 48000, nullptr);

  421.     }

  422.     else

  423.     {

  424.         engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,      CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS, nullptr);

  425.         engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE,    CB::ENGINE_TRANSPORT_MODE_JACK,           nullptr);

  426.     }

  427.     engine->setOption(CB::ENGINE_OPTION_FORCE_STEREO,          false,                                    nullptr);

  428.     engine->setOption(CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES, false,                                    nullptr);

  429.     engine->setOption(CB::ENGINE_OPTION_PREFER_UI_BRIDGES,     false,                                    nullptr);

  430. #else

  431.     engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,          static_cast<int>(shandle.engineOptions.processMode),   nullptr);

  432.     engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE,        static_cast<int>(shandle.engineOptions.transportMode), shandle.engineOptions.transportExtra);

  433. #endif

  434. 

  435.     carla_engine_init_common(shandle, engine);

  436. 

  437.     if (engine->init(clientName))

  438.     {

  439. #ifdef CARLA_CAN_USE_LOG_THREAD

  440.         if (shandle.logThreadEnabled && std::getenv("CARLA_LOGS_DISABLED") == nullptr)

  441.             shandle.logThread.init();

  442. #endif

  443.         shandle.lastError = "No error";

  444.         return true;

  445.     }

  446.     else

  447.     {

  448.         shandle.lastError = engine->getLastError();

  449.         shandle.engine = nullptr;

  450.         delete engine;

  451. #ifdef USING_JUCE

  452.         CarlaJUCE::shutdownJuce_GUI();

  453. #endif

  454.         return false;

  455.     }

  456. }

  457. 

  458. #ifdef BUILD_BRIDGE

  459. bool carla_engine_init_bridge(CarlaHostHandle handle,

  460.                               const char audioBaseName[6+1],

  461.                               const char rtClientBaseName[6+1],

  462.                               const char nonRtClientBaseName[6+1],

  463.                               const char nonRtServerBaseName[6+1],

  464.                               const char* const clientName)

  465. {

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

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

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

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

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

  471.     carla_debug("carla_engine_init_bridge(%p, \"%s\", \"%s\", \"%s\", \"%s\", \"%s\")",

  472.                 handle, audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName, clientName);

  473. 

  474.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->isStandalone, "Must be a standalone host handle", false);

  475.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine == nullptr, "Engine is already initialized", false);

  476. 

  477.     CarlaScopedPointer<CarlaEngine> engine(CB::EngineInit::newBridge(audioBaseName,

  478.                                                                      rtClientBaseName,

  479.                                                                      nonRtClientBaseName,

  480.                                                                      nonRtServerBaseName));

  481. 

  482.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(engine != nullptr, "The selected audio driver is not available", false);

  483. 

  484.     engine->setOption(CB::ENGINE_OPTION_PROCESS_MODE,   CB::ENGINE_PROCESS_MODE_BRIDGE,   nullptr);

  485.     engine->setOption(CB::ENGINE_OPTION_TRANSPORT_MODE, CB::ENGINE_TRANSPORT_MODE_BRIDGE, nullptr);

  486. 

  487.     CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  488. 

  489.     carla_engine_init_common(shandle, engine);

  490. 

  491.     if (engine->init(clientName))

  492.     {

  493.         shandle.lastError = "No error";

  494.         shandle.engine = engine.release();

  495.         return true;

  496.     }

  497.     else

  498.     {

  499.         shandle.lastError = engine->getLastError();

  500.         return false;

  501.     }

  502. }

  503. #endif

  504. 

  505. bool carla_engine_close(CarlaHostHandle handle)

  506. {

  507.     carla_debug("carla_engine_close(%p)", handle);

  508. 

  509.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->isStandalone, "Must be a standalone host handle", false);

  510.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  511. 

  512.     CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  513. 

  514.     CarlaEngine* const engine = shandle.engine;

  515. 

  516.     engine->setAboutToClose();

  517.     engine->removeAllPlugins();

  518. 

  519.     const bool closed = engine->close();

  520. 

  521.     if (! closed)

  522.         shandle.lastError = engine->getLastError();

  523. 

  524. #ifdef CARLA_CAN_USE_LOG_THREAD

  525.     shandle.logThread.stop();

  526. #endif

  527. 

  528.     shandle.engine = nullptr;

  529.     delete engine;

  530. 

  531. #ifdef USING_JUCE

  532.     CarlaJUCE::shutdownJuce_GUI();

  533. #endif

  534.     return closed;

  535. }

  536. 

  537. void carla_engine_idle(CarlaHostHandle handle)

  538. {

  539.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->isStandalone,);

  540. 

  541.     handle->engine->idle();

  542. 

  543. #ifdef USING_JUCE

  544.     if (handle->isStandalone)

  545.         CarlaJUCE::idleJuce_GUI();

  546. #endif

  547. }

  548. 

  549. bool carla_is_engine_running(CarlaHostHandle handle)

  550. {

  551.     return (handle->engine != nullptr && handle->engine->isRunning());

  552. }

  553. 

  554. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  555. {

  556.     static CarlaRuntimeEngineInfo retInfo;

  557. 

  558.     // reset

  559.     retInfo.load = 0.0f;

  560.     retInfo.xruns = 0;

  561. 

  562.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  563. 

  564.     retInfo.load = handle->engine->getDSPLoad();

  565.     retInfo.xruns = handle->engine->getTotalXruns();

  566. 

  567.     return &retInfo;

  568. }

  569. 

  570. #ifndef BUILD_BRIDGE

  571. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  572. {

  573.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  574. 

  575.     // reset

  576.     retInfo.name = gNullCharPtr;

  577.     retInfo.hints = 0x0;

  578.     retInfo.bufferSize = 0;

  579.     retInfo.bufferSizes = nullptr;

  580.     retInfo.sampleRate = 0.0;

  581.     retInfo.sampleRates = nullptr;

  582. 

  583.     const char* audioDriver;

  584.     const char* audioDevice;

  585. 

  586.     if (CarlaEngine* const engine = handle->engine)

  587.     {

  588.         audioDriver = engine->getCurrentDriverName();

  589.         audioDevice = engine->getOptions().audioDevice;

  590. 

  591.         retInfo.bufferSize = engine->getBufferSize();

  592.         retInfo.sampleRate = engine->getSampleRate();

  593.     }

  594.     else if (handle->isStandalone)

  595.     {

  596.         CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  597. 

  598.         audioDriver = shandle.engineOptions.audioDriver;

  599.         audioDevice = shandle.engineOptions.audioDevice;

  600. 

  601.         retInfo.bufferSize = shandle.engineOptions.audioBufferSize;

  602.         retInfo.sampleRate = shandle.engineOptions.audioSampleRate;

  603.     }

  604.     else

  605.     {

  606.         return &retInfo;

  607.     }

  608.     CARLA_SAFE_ASSERT_RETURN(audioDriver != nullptr, &retInfo);

  609.     CARLA_SAFE_ASSERT_RETURN(audioDevice != nullptr, &retInfo);

  610. 

  611.     uint index = 0;

  612.     uint count = CarlaEngine::getDriverCount();

  613.     for (; index<count; ++index)

  614.     {

  615.         const char* const testDriverName = CarlaEngine::getDriverName(index);

  616.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  617. 

  618.         if (std::strcmp(testDriverName, audioDriver) == 0)

  619.             break;

  620.     }

  621.     CARLA_SAFE_ASSERT_RETURN(index != count, &retInfo);

  622. 

  623.     const EngineDriverDeviceInfo* const devInfo = CarlaEngine::getDriverDeviceInfo(index, audioDevice);

  624.     CARLA_SAFE_ASSERT_RETURN(devInfo != nullptr, &retInfo);

  625. 

  626.     retInfo.name        = audioDevice;

  627.     retInfo.hints       = devInfo->hints;

  628.     retInfo.bufferSizes = devInfo->bufferSizes;

  629.     retInfo.sampleRates = devInfo->sampleRates;

  630. 

  631.     return &retInfo;

  632. }

  633. 

  634. bool carla_set_engine_buffer_size_and_sample_rate(CarlaHostHandle handle, uint bufferSize, double sampleRate)

  635. {

  636.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, false);

  637.     carla_debug("carla_set_engine_buffer_size_and_sample_rate(%p, %u, %f)", handle, bufferSize, sampleRate);

  638. 

  639.     return handle->engine->setBufferSizeAndSampleRate(bufferSize, sampleRate);

  640. }

  641. 

  642. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  643. {

  644.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, false);

  645.     carla_debug("carla_show_engine_device_control_panel(%p)", handle);

  646. 

  647.     return handle->engine->showDeviceControlPanel();

  648. }

  649. #endif // BUILD_BRIDGE

  650. 

  651. void carla_clear_engine_xruns(CarlaHostHandle handle)

  652. {

  653.     if (handle->engine != nullptr)

  654.         handle->engine->clearXruns();

  655. }

  656. 

  657. void carla_cancel_engine_action(CarlaHostHandle handle)

  658. {

  659.     if (handle->engine != nullptr)

  660.         handle->engine->setActionCanceled(true);

  661. }

  662. 

  663. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  664. {

  665.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, true);

  666.     carla_debug("carla_set_engine_about_to_close(%p)", handle);

  667. 

  668.     return handle->engine->setAboutToClose();

  669. }

  670. 

  671. void carla_set_engine_callback(CarlaHostHandle handle, EngineCallbackFunc func, void* ptr)

  672. {

  673.     carla_debug("carla_set_engine_callback(%p, %p, %p)", handle, func, ptr);

  674. 

  675.     if (handle->isStandalone)

  676.     {

  677.         CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  678. 

  679.         shandle.engineCallback    = func;

  680.         shandle.engineCallbackPtr = ptr;

  681. 

  682. #ifdef CARLA_CAN_USE_LOG_THREAD

  683.         shandle.logThread.setCallback(func, ptr);

  684. #endif

  685.     }

  686. 

  687.     if (handle->engine != nullptr)

  688.         handle->engine->setCallback(func, ptr);

  689. }

  690. 

  691. void carla_set_engine_option(CarlaHostHandle handle, EngineOption option, int value, const char* valueStr)

  692. {

  693.     carla_debug("carla_set_engine_option(%p, %i:%s, %i, \"%s\")",

  694.                 handle, option, CB::EngineOption2Str(option), value, valueStr);

  695. 

  696.     if (handle->isStandalone)

  697.     {

  698.         CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  699. 

  700.         switch (option)

  701.         {

  702.         case CB::ENGINE_OPTION_DEBUG:

  703.             break;

  704. 

  705.         case CB::ENGINE_OPTION_PROCESS_MODE:

  706.             CARLA_SAFE_ASSERT_RETURN(value >= CB::ENGINE_PROCESS_MODE_SINGLE_CLIENT && value < CB::ENGINE_PROCESS_MODE_BRIDGE,);

  707.             shandle.engineOptions.processMode = static_cast<CB::EngineProcessMode>(value);

  708.             break;

  709. 

  710.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

  711.             CARLA_SAFE_ASSERT_RETURN(value >= CB::ENGINE_TRANSPORT_MODE_DISABLED && value <= CB::ENGINE_TRANSPORT_MODE_BRIDGE,);

  712. 

  713.             // jack transport cannot be disabled in multi-client

  714.             if (shandle.engineOptions.processMode == CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS

  715.                 && value != CB::ENGINE_TRANSPORT_MODE_JACK)

  716.             {

  717.                 shandle.engineOptions.transportMode = CB::ENGINE_TRANSPORT_MODE_JACK;

  718. 

  719.                 if (shandle.engineCallback != nullptr)

  720.                     shandle.engineCallback(shandle.engineCallbackPtr,

  721.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  722.                                            0,

  723.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  724.                                            0, 0, 0.0f,

  725.                                            shandle.engineOptions.transportExtra);

  726.             }

  727.             else

  728.             {

  729.                 shandle.engineOptions.transportMode = static_cast<CB::EngineTransportMode>(value);

  730.             }

  731. 

  732.             delete[] shandle.engineOptions.transportExtra;

  733.             if (value != CB::ENGINE_TRANSPORT_MODE_DISABLED && valueStr != nullptr)

  734.                 shandle.engineOptions.transportExtra = carla_strdup_safe(valueStr);

  735.             else

  736.                 shandle.engineOptions.transportExtra = nullptr;

  737.             break;

  738. 

  739.         case CB::ENGINE_OPTION_FORCE_STEREO:

  740.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  741.             shandle.engineOptions.forceStereo = (value != 0);

  742.             break;

  743. 

  744.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

  745.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  746.             shandle.engineOptions.preferPluginBridges = (value != 0);

  747.             break;

  748. 

  749.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

  750.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  751.             shandle.engineOptions.preferUiBridges = (value != 0);

  752.             break;

  753. 

  754.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

  755.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  756.             shandle.engineOptions.uisAlwaysOnTop = (value != 0);

  757.             break;

  758. 

  759.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  760.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  761.             shandle.engineOptions.maxParameters = static_cast<uint>(value);

  762.             break;

  763. 

  764.         case CB::ENGINE_OPTION_RESET_XRUNS:

  765.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  766.             shandle.engineOptions.resetXruns = (value != 0);

  767.             break;

  768. 

  769.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  770.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  771.             shandle.engineOptions.uiBridgesTimeout = static_cast<uint>(value);

  772.             break;

  773. 

  774.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  775.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

  776.             shandle.engineOptions.audioBufferSize = static_cast<uint>(value);

  777.             break;

  778. 

  779.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  780.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

  781.             shandle.engineOptions.audioSampleRate = static_cast<uint>(value);

  782.             break;

  783. 

  784.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

  785.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  786.             shandle.engineOptions.audioTripleBuffer = (value != 0);

  787.             break;

  788. 

  789.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  790.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  791. 

  792.             if (shandle.engineOptions.audioDriver != nullptr)

  793.                 delete[] shandle.engineOptions.audioDriver;

  794. 

  795.             shandle.engineOptions.audioDriver = carla_strdup_safe(valueStr);

  796.             break;

  797. 

  798.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  799.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  800. 

  801.             if (shandle.engineOptions.audioDevice != nullptr)

  802.                 delete[] shandle.engineOptions.audioDevice;

  803. 

  804.             shandle.engineOptions.audioDevice = carla_strdup_safe(valueStr);

  805.             break;

  806. 

  807. #ifndef BUILD_BRIDGE

  808.         case CB::ENGINE_OPTION_OSC_ENABLED:

  809.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  810.             shandle.engineOptions.oscEnabled = (value != 0);

  811.             break;

  812. 

  813.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

  814.             CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  815.             shandle.engineOptions.oscPortTCP = value;

  816.             break;

  817. 

  818.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

  819.             CARLA_SAFE_ASSERT_RETURN(value <= 0 || value >= 1024,);

  820.             shandle.engineOptions.oscPortUDP = value;

  821.             break;

  822. #endif

  823. 

  824.         case CB::ENGINE_OPTION_FILE_PATH:

  825.             CARLA_SAFE_ASSERT_RETURN(value > CB::FILE_NONE,);

  826.             CARLA_SAFE_ASSERT_RETURN(value <= CB::FILE_MIDI,);

  827.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  828. 

  829.             switch (value)

  830.             {

  831.             case CB::FILE_AUDIO:

  832.                 if (shandle.engineOptions.pathAudio != nullptr)

  833.                     delete[] shandle.engineOptions.pathAudio;

  834.                 shandle.engineOptions.pathAudio = carla_strdup_safe(valueStr);

  835.                 break;

  836.             case CB::FILE_MIDI:

  837.                 if (shandle.engineOptions.pathMIDI != nullptr)

  838.                     delete[] shandle.engineOptions.pathMIDI;

  839.                 shandle.engineOptions.pathMIDI = carla_strdup_safe(valueStr);

  840.                 break;

  841.             }

  842.             break;

  843. 

  844.         case CB::ENGINE_OPTION_PLUGIN_PATH:

  845.             CARLA_SAFE_ASSERT_RETURN(value > CB::PLUGIN_NONE,);

  846.             CARLA_SAFE_ASSERT_RETURN(value <= CB::PLUGIN_JSFX,);

  847.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  848. 

  849.             switch (value)

  850.             {

  851.             case CB::PLUGIN_LADSPA:

  852.                 if (shandle.engineOptions.pathLADSPA != nullptr)

  853.                     delete[] shandle.engineOptions.pathLADSPA;

  854.                 shandle.engineOptions.pathLADSPA = carla_strdup_safe(valueStr);

  855.                 break;

  856.             case CB::PLUGIN_DSSI:

  857.                 if (shandle.engineOptions.pathDSSI != nullptr)

  858.                     delete[] shandle.engineOptions.pathDSSI;

  859.                 shandle.engineOptions.pathDSSI = carla_strdup_safe(valueStr);

  860.                 break;

  861.             case CB::PLUGIN_LV2:

  862.                 if (shandle.engineOptions.pathLV2 != nullptr)

  863.                     delete[] shandle.engineOptions.pathLV2;

  864.                 shandle.engineOptions.pathLV2 = carla_strdup_safe(valueStr);

  865.                 break;

  866.             case CB::PLUGIN_VST2:

  867.                 if (shandle.engineOptions.pathVST2 != nullptr)

  868.                     delete[] shandle.engineOptions.pathVST2;

  869.                 shandle.engineOptions.pathVST2 = carla_strdup_safe(valueStr);

  870.                 break;

  871.             case CB::PLUGIN_VST3:

  872.                 if (shandle.engineOptions.pathVST3 != nullptr)

  873.                     delete[] shandle.engineOptions.pathVST3;

  874.                 shandle.engineOptions.pathVST3 = carla_strdup_safe(valueStr);

  875.                 break;

  876.             case CB::PLUGIN_SF2:

  877.                 if (shandle.engineOptions.pathSF2 != nullptr)

  878.                     delete[] shandle.engineOptions.pathSF2;

  879.                 shandle.engineOptions.pathSF2 = carla_strdup_safe(valueStr);

  880.                 break;

  881.             case CB::PLUGIN_SFZ:

  882.                 if (shandle.engineOptions.pathSFZ != nullptr)

  883.                     delete[] shandle.engineOptions.pathSFZ;

  884.                 shandle.engineOptions.pathSFZ = carla_strdup_safe(valueStr);

  885.                 break;

  886.             case CB::PLUGIN_JSFX:

  887.                 if (shandle.engineOptions.pathJSFX != nullptr)

  888.                     delete[] shandle.engineOptions.pathJSFX;

  889.                 shandle.engineOptions.pathJSFX = carla_strdup_safe(valueStr);

  890.                 break;

  891.             }

  892.             break;

  893. 

  894.         case CB::ENGINE_OPTION_PATH_BINARIES:

  895.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  896. 

  897.             if (shandle.engineOptions.binaryDir != nullptr)

  898.                 delete[] shandle.engineOptions.binaryDir;

  899. 

  900.             shandle.engineOptions.binaryDir = carla_strdup_safe(valueStr);

  901.             break;

  902. 

  903.         case CB::ENGINE_OPTION_PATH_RESOURCES:

  904.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  905. 

  906.             if (shandle.engineOptions.resourceDir != nullptr)

  907.                 delete[] shandle.engineOptions.resourceDir;

  908. 

  909.             shandle.engineOptions.resourceDir = carla_strdup_safe(valueStr);

  910.             break;

  911. 

  912.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

  913.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  914.             shandle.engineOptions.preventBadBehaviour = (value != 0);

  915.             break;

  916. 

  917.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

  918.             shandle.engineOptions.bgColor = static_cast<uint>(value);

  919.             break;

  920. 

  921.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

  922.             shandle.engineOptions.fgColor = static_cast<uint>(value);

  923.             break;

  924. 

  925.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  926.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

  927.             shandle.engineOptions.uiScale = static_cast<float>(value) / 1000;

  928.             break;

  929. 

  930.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

  931.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  932.             const long long winId(std::strtoll(valueStr, nullptr, 16));

  933.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

  934.             shandle.engineOptions.frontendWinId = static_cast<uintptr_t>(winId);

  935.         }   break;

  936. 

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

  938.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

  939.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  940. 

  941.             if (shandle.engineOptions.wine.executable != nullptr)

  942.                 delete[] shandle.engineOptions.wine.executable;

  943. 

  944.             shandle.engineOptions.wine.executable = carla_strdup_safe(valueStr);

  945.             break;

  946. 

  947.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

  948.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  949.             shandle.engineOptions.wine.autoPrefix = (value != 0);

  950.             break;

  951. 

  952.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

  953.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr && valueStr[0] != '\0',);

  954. 

  955.             if (shandle.engineOptions.wine.fallbackPrefix != nullptr)

  956.                 delete[] shandle.engineOptions.wine.fallbackPrefix;

  957. 

  958.             shandle.engineOptions.wine.fallbackPrefix = carla_strdup_safe(valueStr);

  959.             break;

  960. 

  961.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

  962.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  963.             shandle.engineOptions.wine.rtPrio = (value != 0);

  964.             break;

  965. 

  966.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

  967.             CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 89,);

  968.             shandle.engineOptions.wine.baseRtPrio = value;

  969.             break;

  970. 

  971.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

  972.             CARLA_SAFE_ASSERT_RETURN(value >= 1 && value <= 99,);

  973.             shandle.engineOptions.wine.serverRtPrio = value;

  974.             break;

  975. #endif

  976. 

  977. #ifndef BUILD_BRIDGE

  978.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  979. #ifdef CARLA_CAN_USE_LOG_THREAD

  980.             shandle.logThreadEnabled = (value != 0);

  981. #endif

  982.             break;

  983. #endif

  984. 

  985.         case CB::ENGINE_OPTION_CLIENT_NAME_PREFIX:

  986.             if (shandle.engineOptions.clientNamePrefix != nullptr)

  987.                 delete[] shandle.engineOptions.clientNamePrefix;

  988. 

  989.             shandle.engineOptions.clientNamePrefix = valueStr != nullptr && valueStr[0] != '\0'

  990.                                                    ? carla_strdup_safe(valueStr)

  991.                                                    : nullptr;

  992.             break;

  993. 

  994.         case CB::ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

  995.             CARLA_SAFE_ASSERT_RETURN(value == 0 || value == 1,);

  996.             shandle.engineOptions.pluginsAreStandalone = (value != 0);

  997.             break;

  998.         }

  999.     }

  1000. 

  1001.     if (handle->engine != nullptr)

  1002.         handle->engine->setOption(option, value, valueStr);

  1003. }

  1004. 

  1005. void carla_set_file_callback(CarlaHostHandle handle, FileCallbackFunc func, void* ptr)

  1006. {

  1007.     carla_debug("carla_set_file_callback(%p, %p, %p)", handle, func, ptr);

  1008. 

  1009.     if (handle->isStandalone)

  1010.     {

  1011.         CarlaHostStandalone& shandle((CarlaHostStandalone&)*handle);

  1012. 

  1013.         shandle.fileCallback    = func;

  1014.         shandle.fileCallbackPtr = ptr;

  1015.     }

  1016. 

  1017.     if (handle->engine != nullptr)

  1018.         handle->engine->setFileCallback(func, ptr);

  1019. }

  1020. 

  1021. // --------------------------------------------------------------------------------------------------------------------

  1022. 

  1023. bool carla_load_file(CarlaHostHandle handle, const char* filename)

  1024. {

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

  1026.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1027. 

  1028.     carla_debug("carla_load_file(%p, \"%s\")", handle, filename);

  1029. 

  1030.     return handle->engine->loadFile(filename);

  1031. }

  1032. 

  1033. bool carla_load_project(CarlaHostHandle handle, const char* filename)

  1034. {

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

  1036.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1037. 

  1038.     carla_debug("carla_load_project(%p, \"%s\")", handle, filename);

  1039. 

  1040.     return handle->engine->loadProject(filename, true);

  1041. }

  1042. 

  1043. bool carla_save_project(CarlaHostHandle handle, const char* filename)

  1044. {

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

  1046.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1047. 

  1048.     carla_debug("carla_save_project(%p, \"%s\")", handle, filename);

  1049. 

  1050.     return handle->engine->saveProject(filename, true);

  1051. }

  1052. 

  1053. #ifndef BUILD_BRIDGE

  1054. const char* carla_get_current_project_folder(CarlaHostHandle handle)

  1055. {

  1056.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, gNullCharPtr);

  1057. 

  1058.     carla_debug("carla_get_current_project_folder(%p)", handle);

  1059. 

  1060.     if (const char* const ret = handle->engine->getCurrentProjectFolder())

  1061.         return ret;

  1062. 

  1063.     return gNullCharPtr;

  1064. }

  1065. 

  1066. const char* carla_get_current_project_filename(CarlaHostHandle handle)

  1067. {

  1068.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->isStandalone, gNullCharPtr);

  1069. 

  1070.     carla_debug("carla_get_current_project_filename(%p)", handle);

  1071. 

  1072.     if (const char* const ret = handle->engine->getCurrentProjectFilename())

  1073.         return ret;

  1074. 

  1075.     return gNullCharPtr;

  1076. }

  1077. 

  1078. void carla_clear_project_filename(CarlaHostHandle handle)

  1079. {

  1080.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  1081. 

  1082.     carla_debug("carla_clear_project_filename(%p)", handle);

  1083. 

  1084.     handle->engine->clearCurrentProjectFilename();

  1085. }

  1086. 

  1087. // --------------------------------------------------------------------------------------------------------------------

  1088. 

  1089. bool carla_patchbay_connect(CarlaHostHandle handle, bool external, uint groupIdA, uint portIdA, uint groupIdB, uint portIdB)

  1090. {

  1091.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1092. 

  1093.     carla_debug("carla_patchbay_connect(%p, %s, %u, %u, %u, %u)",

  1094.                 handle, bool2str(external), groupIdA, portIdA, groupIdB, portIdB);

  1095. 

  1096.     return handle->engine->patchbayConnect(external, groupIdA, portIdA, groupIdB, portIdB);

  1097. }

  1098. 

  1099. bool carla_patchbay_disconnect(CarlaHostHandle handle, bool external, uint connectionId)

  1100. {

  1101.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1102. 

  1103.     carla_debug("carla_patchbay_disconnect(%p, %s, %i)", handle, bool2str(external), connectionId);

  1104. 

  1105.     return handle->engine->patchbayDisconnect(external, connectionId);

  1106. }

  1107. 

  1108. bool carla_patchbay_set_group_pos(CarlaHostHandle handle, bool external, uint groupId, int x1, int y1, int x2, int y2)

  1109. {

  1110.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr && handle->engine->isRunning(),

  1111.                                              "Engine is not running", false);

  1112. 

  1113.     carla_debug("carla_patchbay_set_group_pos(%p, %s, %u, %i, %i, %i, %i)",

  1114.                 handle, bool2str(external), groupId, x1, y1, x2, y2);

  1115. 

  1116.     if (handle->engine->isAboutToClose())

  1117.         return true;

  1118. 

  1119.     return handle->engine->patchbaySetGroupPos(false, true, external, groupId, x1, y1, x2, y2);

  1120. }

  1121. 

  1122. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  1123. {

  1124.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1125. 

  1126.     carla_debug("carla_patchbay_refresh(%p, %s)", handle, bool2str(external));

  1127. 

  1128.     return handle->engine->patchbayRefresh(true, false, external);

  1129. }

  1130. 

  1131. // --------------------------------------------------------------------------------------------------------------------

  1132. 

  1133. void carla_transport_play(CarlaHostHandle handle)

  1134. {

  1135.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(),);

  1136. 

  1137.     carla_debug("carla_transport_play(%p)", handle);

  1138. 

  1139.     handle->engine->transportPlay();

  1140. }

  1141. 

  1142. void carla_transport_pause(CarlaHostHandle handle)

  1143. {

  1144.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(),);

  1145. 

  1146.     carla_debug("carla_transport_pause(%p)", handle);

  1147. 

  1148.     handle->engine->transportPause();

  1149. }

  1150. 

  1151. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1152. {

  1153.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(),);

  1154. 

  1155.     carla_debug("carla_transport_bpm(%p, %f)", handle, bpm);

  1156. 

  1157.     handle->engine->transportBPM(bpm);

  1158. }

  1159. 

  1160. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1161. {

  1162.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(),);

  1163. 

  1164.     carla_debug("carla_transport_relocate(%p, %i)", handle, frame);

  1165. 

  1166.     handle->engine->transportRelocate(frame);

  1167. }

  1168. 

  1169. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1170. {

  1171.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(), 0);

  1172. 

  1173.     return handle->engine->getTimeInfo().frame;

  1174. }

  1175. 

  1176. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1177. {

  1178.     static CarlaTransportInfo retTransInfo;

  1179.     retTransInfo.clear();

  1180. 

  1181.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(), &retTransInfo);

  1182. 

  1183.     const CB::EngineTimeInfo& timeInfo(handle->engine->getTimeInfo());

  1184. 

  1185.     retTransInfo.playing = timeInfo.playing;

  1186.     retTransInfo.frame   = timeInfo.frame;

  1187. 

  1188.     if (timeInfo.bbt.valid)

  1189.     {

  1190.         retTransInfo.bar  = timeInfo.bbt.bar;

  1191.         retTransInfo.beat = timeInfo.bbt.beat;

  1192.         retTransInfo.tick = static_cast<int32_t>(timeInfo.bbt.tick + 0.5);

  1193.         retTransInfo.bpm  = timeInfo.bbt.beatsPerMinute;

  1194.     }

  1195. 

  1196.     return &retTransInfo;

  1197. }

  1198. #endif

  1199. 

  1200. // --------------------------------------------------------------------------------------------------------------------

  1201. 

  1202. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1203. {

  1204.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1205. 

  1206.     carla_debug("carla_get_current_plugin_count(%p)", handle);

  1207. 

  1208.     return handle->engine->getCurrentPluginCount();

  1209. }

  1210. 

  1211. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1212. {

  1213.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1214. 

  1215.     carla_debug("carla_get_max_plugin_number(%p)", handle);

  1216. 

  1217.     return handle->engine->getMaxPluginNumber();

  1218. }

  1219. 

  1220. // --------------------------------------------------------------------------------------------------------------------

  1221. 

  1222. bool carla_add_plugin(CarlaHostHandle handle,

  1223.                       BinaryType btype, PluginType ptype,

  1224.                       const char* filename, const char* name, const char* label, int64_t uniqueId,

  1225.                       const void* extraPtr, uint options)

  1226. {

  1227.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1228. 

  1229.     carla_debug("carla_add_plugin(%p, %i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p, %u)",

  1230.                 handle,

  1231.                 btype, CB::BinaryType2Str(btype),

  1232.                 ptype, CB::PluginType2Str(ptype),

  1233.                 filename, name, label, uniqueId, extraPtr, options);

  1234. 

  1235.     return handle->engine->addPlugin(btype, ptype, filename, name, label, uniqueId, extraPtr, options);

  1236. }

  1237. 

  1238. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1239. {

  1240.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1241. 

  1242.     carla_debug("carla_remove_plugin(%p, %i)", handle, pluginId);

  1243. 

  1244.     return handle->engine->removePlugin(pluginId);

  1245. }

  1246. 

  1247. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1248. {

  1249.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1250. 

  1251.     carla_debug("carla_remove_all_plugins(%p)", handle);

  1252. 

  1253.     return handle->engine->removeAllPlugins();

  1254. }

  1255. 

  1256. #ifndef BUILD_BRIDGE

  1257. bool carla_rename_plugin(CarlaHostHandle handle, uint pluginId, const char* newName)

  1258. {

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

  1260.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1261. 

  1262.     carla_debug("carla_rename_plugin(%p, %i, \"%s\")", handle, pluginId, newName);

  1263. 

  1264.     return handle->engine->renamePlugin(pluginId, newName);

  1265. }

  1266. 

  1267. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1268. {

  1269.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1270. 

  1271.     carla_debug("carla_clone_plugin(%p, %i)", handle, pluginId);

  1272. 

  1273.     return handle->engine->clonePlugin(pluginId);

  1274. }

  1275. 

  1276. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1277. {

  1278.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1279. 

  1280.     carla_debug("carla_replace_plugin(%p, %i)", handle, pluginId);

  1281. 

  1282.     return handle->engine->replacePlugin(pluginId);

  1283. }

  1284. 

  1285. bool carla_switch_plugins(CarlaHostHandle handle, uint pluginIdA, uint pluginIdB)

  1286. {

  1287.     CARLA_SAFE_ASSERT_RETURN(pluginIdA != pluginIdB, false);

  1288.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1289. 

  1290.     carla_debug("carla_switch_plugins(%p, %i, %i)", handle, pluginIdA, pluginIdB);

  1291. 

  1292.     return handle->engine->switchPlugins(pluginIdA, pluginIdB);

  1293. }

  1294. #endif

  1295. 

  1296. // --------------------------------------------------------------------------------------------------------------------

  1297. 

  1298. bool carla_load_plugin_state(CarlaHostHandle handle, uint pluginId, const char* filename)

  1299. {

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

  1301.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

  1302.                                           && handle->engine->isRunning(), "Engine is not running", false);

  1303. 

  1304.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1305.         return plugin->loadStateFromFile(filename);

  1306. 

  1307.     return false;

  1308. }

  1309. 

  1310. bool carla_save_plugin_state(CarlaHostHandle handle, uint pluginId, const char* filename)

  1311. {

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

  1313.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1314. 

  1315.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1316.         return plugin->saveStateToFile(filename);

  1317. 

  1318.     return false;

  1319. }

  1320. 

  1321. bool carla_export_plugin_lv2(CarlaHostHandle handle, uint pluginId, const char* lv2path)

  1322. {

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

  1324.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr, "Engine is not initialized", false);

  1325. 

  1326.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1327.         return plugin->exportAsLV2(lv2path);

  1328. 

  1329.     return false;

  1330. }

  1331. 

  1332. // --------------------------------------------------------------------------------------------------------------------

  1333. 

  1334. const CarlaPluginInfo* carla_get_plugin_info(CarlaHostHandle handle, uint pluginId)

  1335. {

  1336.     static CarlaPluginInfo retInfo;

  1337. 

  1338.     // reset

  1339.     retInfo.type             = CB::PLUGIN_NONE;

  1340.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1341.     retInfo.hints            = 0x0;

  1342.     retInfo.optionsAvailable = 0x0;

  1343.     retInfo.optionsEnabled   = 0x0;

  1344.     retInfo.filename         = gNullCharPtr;

  1345.     retInfo.name             = gNullCharPtr;

  1346.     retInfo.iconName         = gNullCharPtr;

  1347.     retInfo.uniqueId         = 0;

  1348. 

  1349.     // cleanup

  1350.     if (retInfo.label != gNullCharPtr)

  1351.     {

  1352.         delete[] retInfo.label;

  1353.         retInfo.label = gNullCharPtr;

  1354.     }

  1355. 

  1356.     if (retInfo.maker != gNullCharPtr)

  1357.     {

  1358.         delete[] retInfo.maker;

  1359.         retInfo.maker = gNullCharPtr;

  1360.     }

  1361. 

  1362.     if (retInfo.copyright != gNullCharPtr)

  1363.     {

  1364.         delete[] retInfo.copyright;

  1365.         retInfo.copyright = gNullCharPtr;

  1366.     }

  1367. 

  1368.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  1369. 

  1370.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1371.     {

  1372.         char strBuf[STR_MAX+1];

  1373.         carla_zeroChars(strBuf, STR_MAX+1);

  1374. 

  1375.         retInfo.type     = plugin->getType();

  1376.         retInfo.category = plugin->getCategory();

  1377.         retInfo.hints    = plugin->getHints();

  1378.         retInfo.filename = plugin->getFilename();

  1379.         retInfo.name     = plugin->getName();

  1380.         retInfo.iconName = plugin->getIconName();

  1381.         retInfo.uniqueId = plugin->getUniqueId();

  1382. 

  1383.         retInfo.optionsAvailable = plugin->getOptionsAvailable();

  1384.         retInfo.optionsEnabled   = plugin->getOptionsEnabled();

  1385. 

  1386.         if (plugin->getLabel(strBuf))

  1387.             retInfo.label = carla_strdup_safe(strBuf);

  1388.         if (plugin->getMaker(strBuf))

  1389.             retInfo.maker = carla_strdup_safe(strBuf);

  1390.         if (plugin->getCopyright(strBuf))

  1391.             retInfo.copyright = carla_strdup_safe(strBuf);

  1392. 

  1393.         checkStringPtr(retInfo.filename);

  1394.         checkStringPtr(retInfo.name);

  1395.         checkStringPtr(retInfo.iconName);

  1396.         checkStringPtr(retInfo.label);

  1397.         checkStringPtr(retInfo.maker);

  1398.         checkStringPtr(retInfo.copyright);

  1399.     }

  1400. 

  1401.     return &retInfo;

  1402. }

  1403. 

  1404. const CarlaPortCountInfo* carla_get_audio_port_count_info(CarlaHostHandle handle, uint pluginId)

  1405. {

  1406.     static CarlaPortCountInfo retInfo;

  1407.     carla_zeroStruct(retInfo);

  1408. 

  1409.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  1410. 

  1411.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1412.     {

  1413.         retInfo.ins   = plugin->getAudioInCount();

  1414.         retInfo.outs  = plugin->getAudioOutCount();

  1415.     }

  1416. 

  1417.     return &retInfo;

  1418. }

  1419. 

  1420. const CarlaPortCountInfo* carla_get_midi_port_count_info(CarlaHostHandle handle, uint pluginId)

  1421. {

  1422.     static CarlaPortCountInfo retInfo;

  1423.     carla_zeroStruct(retInfo);

  1424. 

  1425.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  1426. 

  1427.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1428.     {

  1429.         retInfo.ins   = plugin->getMidiInCount();

  1430.         retInfo.outs  = plugin->getMidiOutCount();

  1431.     }

  1432. 

  1433.     return &retInfo;

  1434. }

  1435. 

  1436. const CarlaPortCountInfo* carla_get_parameter_count_info(CarlaHostHandle handle, uint pluginId)

  1437. {

  1438.     static CarlaPortCountInfo retInfo;

  1439.     carla_zeroStruct(retInfo);

  1440. 

  1441.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  1442. 

  1443.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1444.         plugin->getParameterCountInfo(retInfo.ins, retInfo.outs);

  1445. 

  1446.     return &retInfo;

  1447. }

  1448. 

  1449. const CarlaParameterInfo* carla_get_parameter_info(CarlaHostHandle handle, uint pluginId, uint32_t parameterId)

  1450. {

  1451.     static CarlaParameterInfo retInfo;

  1452. 

  1453.     // reset

  1454.     retInfo.scalePointCount = 0;

  1455. 

  1456.     // cleanup

  1457.     if (retInfo.name != gNullCharPtr)

  1458.     {

  1459.         delete[] retInfo.name;

  1460.         retInfo.name = gNullCharPtr;

  1461.     }

  1462. 

  1463.     if (retInfo.symbol != gNullCharPtr)

  1464.     {

  1465.         delete[] retInfo.symbol;

  1466.         retInfo.symbol = gNullCharPtr;

  1467.     }

  1468. 

  1469.     if (retInfo.unit != gNullCharPtr)

  1470.     {

  1471.         delete[] retInfo.unit;

  1472.         retInfo.unit = gNullCharPtr;

  1473.     }

  1474. 

  1475.     if (retInfo.comment != gNullCharPtr)

  1476.     {

  1477.         delete[] retInfo.comment;

  1478.         retInfo.comment = gNullCharPtr;

  1479.     }

  1480. 

  1481.     if (retInfo.groupName != gNullCharPtr)

  1482.     {

  1483.         delete[] retInfo.groupName;

  1484.         retInfo.groupName = gNullCharPtr;

  1485.     }

  1486. 

  1487.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  1488. 

  1489.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1490.     {

  1491.         char strBuf[STR_MAX+1];

  1492.         carla_zeroChars(strBuf, STR_MAX+1);

  1493. 

  1494.         retInfo.scalePointCount = plugin->getParameterScalePointCount(parameterId);

  1495. 

  1496.         if (plugin->getParameterName(parameterId, strBuf))

  1497.         {

  1498.             retInfo.name = carla_strdup_safe(strBuf);

  1499.             carla_zeroChars(strBuf, STR_MAX+1);

  1500.         }

  1501. 

  1502.         if (plugin->getParameterSymbol(parameterId, strBuf))

  1503.         {

  1504.             retInfo.symbol = carla_strdup_safe(strBuf);

  1505.             carla_zeroChars(strBuf, STR_MAX+1);

  1506.         }

  1507. 

  1508.         if (plugin->getParameterUnit(parameterId, strBuf))

  1509.         {

  1510.             retInfo.unit = carla_strdup_safe(strBuf);

  1511.             carla_zeroChars(strBuf, STR_MAX+1);

  1512.         }

  1513. 

  1514.         if (plugin->getParameterComment(parameterId, strBuf))

  1515.         {

  1516.             retInfo.comment = carla_strdup_safe(strBuf);

  1517.             carla_zeroChars(strBuf, STR_MAX+1);

  1518.         }

  1519. 

  1520.         if (plugin->getParameterGroupName(parameterId, strBuf))

  1521.         {

  1522.             retInfo.groupName = carla_strdup_safe(strBuf);

  1523.             carla_zeroChars(strBuf, STR_MAX+1);

  1524.         }

  1525. 

  1526.         checkStringPtr(retInfo.name);

  1527.         checkStringPtr(retInfo.symbol);

  1528.         checkStringPtr(retInfo.unit);

  1529.         checkStringPtr(retInfo.comment);

  1530.         checkStringPtr(retInfo.groupName);

  1531.     }

  1532. 

  1533.     return &retInfo;

  1534. }

  1535. 

  1536. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1537.                                                                uint pluginId,

  1538.                                                                uint32_t parameterId,

  1539.                                                                uint32_t scalePointId)

  1540. {

  1541.     CARLA_ASSERT(handle->engine != nullptr);

  1542. 

  1543.     static CarlaScalePointInfo retInfo;

  1544. 

  1545.     // reset

  1546.     retInfo.value = 0.0f;

  1547. 

  1548.     // cleanup

  1549.     if (retInfo.label != gNullCharPtr)

  1550.     {

  1551.         delete[] retInfo.label;

  1552.         retInfo.label = gNullCharPtr;

  1553.     }

  1554. 

  1555.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retInfo);

  1556. 

  1557.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1558.     {

  1559.         char strBuf[STR_MAX+1];

  1560. 

  1561.         retInfo.value = plugin->getParameterScalePointValue(parameterId, scalePointId);

  1562. 

  1563.         carla_zeroChars(strBuf, STR_MAX+1);

  1564.         if (plugin->getParameterScalePointLabel(parameterId, scalePointId, strBuf))

  1565.             retInfo.label = carla_strdup_safe(strBuf);

  1566. 

  1567.         checkStringPtr(retInfo.label);

  1568.     }

  1569. 

  1570.     return &retInfo;

  1571. }

  1572. 

  1573. // --------------------------------------------------------------------------------------------------------------------

  1574. 

  1575. uint carla_get_audio_port_hints(CarlaHostHandle handle, uint pluginId, bool isOutput, uint32_t portIndex)

  1576. {

  1577.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0x0);

  1578. 

  1579.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1580.     {

  1581.         CARLA_SAFE_ASSERT_RETURN(portIndex < (isOutput ? plugin->getAudioOutCount() : plugin->getAudioInCount()), 0x0);

  1582. 

  1583.         return plugin->getAudioPortHints(isOutput, portIndex);

  1584.     }

  1585. 

  1586.     return 0x0;

  1587. }

  1588. 

  1589. // --------------------------------------------------------------------------------------------------------------------

  1590. 

  1591. const ParameterData* carla_get_parameter_data(CarlaHostHandle handle, uint pluginId, uint32_t parameterId)

  1592. {

  1593.     static ParameterData retParamData;

  1594. 

  1595.     // reset

  1596.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1597.     retParamData.hints       = 0x0;

  1598.     retParamData.index       = CB::PARAMETER_NULL;

  1599.     retParamData.rindex      = -1;

  1600.     retParamData.midiChannel = 0;

  1601.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1602.     retParamData.mappedMinimum = 0.0f;

  1603.     retParamData.mappedMaximum = 0.0f;

  1604. 

  1605.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retParamData);

  1606. 

  1607.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1608.     {

  1609.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), &retParamData);

  1610. 

  1611.         const ParameterData& pluginParamData(plugin->getParameterData(parameterId));

  1612.         retParamData.type        = pluginParamData.type;

  1613.         retParamData.hints       = pluginParamData.hints;

  1614.         retParamData.index       = pluginParamData.index;

  1615.         retParamData.rindex      = pluginParamData.rindex;

  1616.         retParamData.midiChannel = pluginParamData.midiChannel;

  1617.         retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1618.         retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1619.         retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1620.     }

  1621. 

  1622.     return &retParamData;

  1623. }

  1624. 

  1625. const ParameterRanges* carla_get_parameter_ranges(CarlaHostHandle handle, uint pluginId, uint32_t parameterId)

  1626. {

  1627.     static ParameterRanges retParamRanges;

  1628. 

  1629.     // reset

  1630.     retParamRanges.def       = 0.0f;

  1631.     retParamRanges.min       = 0.0f;

  1632.     retParamRanges.max       = 1.0f;

  1633.     retParamRanges.step      = 0.01f;

  1634.     retParamRanges.stepSmall = 0.0001f;

  1635.     retParamRanges.stepLarge = 0.1f;

  1636. 

  1637.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retParamRanges);

  1638. 

  1639.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1640.     {

  1641.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), &retParamRanges);

  1642. 

  1643.         const ParameterRanges& pluginParamRanges(plugin->getParameterRanges(parameterId));

  1644.         retParamRanges.def       = pluginParamRanges.def;

  1645.         retParamRanges.min       = pluginParamRanges.min;

  1646.         retParamRanges.max       = pluginParamRanges.max;

  1647.         retParamRanges.step      = pluginParamRanges.step;

  1648.         retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1649.         retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1650.     }

  1651. 

  1652.     return &retParamRanges;

  1653. }

  1654. 

  1655. const MidiProgramData* carla_get_midi_program_data(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId)

  1656. {

  1657.     static MidiProgramData retMidiProgData = { 0, 0, gNullCharPtr };

  1658. 

  1659.     // reset

  1660.     retMidiProgData.bank    = 0;

  1661.     retMidiProgData.program = 0;

  1662. 

  1663.     if (retMidiProgData.name != gNullCharPtr)

  1664.     {

  1665.         delete[] retMidiProgData.name;

  1666.         retMidiProgData.name = gNullCharPtr;

  1667.     }

  1668. 

  1669.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retMidiProgData);

  1670. 

  1671.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1672.     {

  1673.         CARLA_SAFE_ASSERT_RETURN(midiProgramId < plugin->getMidiProgramCount(), &retMidiProgData);

  1674. 

  1675.         const MidiProgramData& pluginMidiProgData(plugin->getMidiProgramData(midiProgramId));

  1676.         retMidiProgData.bank    = pluginMidiProgData.bank;

  1677.         retMidiProgData.program = pluginMidiProgData.program;

  1678. 

  1679.         if (pluginMidiProgData.name != nullptr)

  1680.         {

  1681.             retMidiProgData.name = carla_strdup_safe(pluginMidiProgData.name);

  1682.             checkStringPtr(retMidiProgData.name);

  1683.         }

  1684.         else

  1685.         {

  1686.             retMidiProgData.name = gNullCharPtr;

  1687.         }

  1688.     }

  1689. 

  1690.     return &retMidiProgData;

  1691. }

  1692. 

  1693. const CustomData* carla_get_custom_data(CarlaHostHandle handle, uint pluginId, uint32_t customDataId)

  1694. {

  1695.     static CustomData retCustomData = { gNullCharPtr, gNullCharPtr, gNullCharPtr };

  1696. 

  1697.     // reset

  1698.     if (retCustomData.type != gNullCharPtr)

  1699.     {

  1700.         delete[] retCustomData.type;

  1701.         retCustomData.type = gNullCharPtr;

  1702.     }

  1703. 

  1704.     if (retCustomData.key != gNullCharPtr)

  1705.     {

  1706.         delete[] retCustomData.key;

  1707.         retCustomData.key = gNullCharPtr;

  1708.     }

  1709. 

  1710.     if (retCustomData.value != gNullCharPtr)

  1711.     {

  1712.         delete[] retCustomData.value;

  1713.         retCustomData.value = gNullCharPtr;

  1714.     }

  1715. 

  1716.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, &retCustomData);

  1717. 

  1718.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1719.     {

  1720.         CARLA_SAFE_ASSERT_RETURN(customDataId < plugin->getCustomDataCount(), &retCustomData)

  1721. 

  1722.         const CustomData& pluginCustomData(plugin->getCustomData(customDataId));

  1723.         retCustomData.type  = carla_strdup_safe(pluginCustomData.type);

  1724.         retCustomData.key   = carla_strdup_safe(pluginCustomData.key);

  1725.         retCustomData.value = carla_strdup_safe(pluginCustomData.value);

  1726.         checkStringPtr(retCustomData.type);

  1727.         checkStringPtr(retCustomData.key);

  1728.         checkStringPtr(retCustomData.value);

  1729.     }

  1730. 

  1731.     return &retCustomData;

  1732. }

  1733. 

  1734. const char* carla_get_custom_data_value(CarlaHostHandle handle, uint pluginId, const char* type, const char* key)

  1735. {

  1736.     CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0', gNullCharPtr);

  1737.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0', gNullCharPtr);

  1738.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, gNullCharPtr);

  1739. 

  1740.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1741.     {

  1742.         const uint32_t count = plugin->getCustomDataCount();

  1743. 

  1744.         if (count == 0)

  1745.             return gNullCharPtr;

  1746. 

  1747.         static CarlaString customDataValue;

  1748. 

  1749.         for (uint32_t i=0; i<count; ++i)

  1750.         {

  1751.             const CustomData& pluginCustomData(plugin->getCustomData(i));

  1752. 

  1753.             if (std::strcmp(pluginCustomData.type, type) != 0)

  1754.                 continue;

  1755.             if (std::strcmp(pluginCustomData.key, key) != 0)

  1756.                 continue;

  1757. 

  1758.             customDataValue = pluginCustomData.value;

  1759.             return customDataValue.buffer();

  1760.         }

  1761.     }

  1762. 

  1763.     return gNullCharPtr;

  1764. }

  1765. 

  1766. const char* carla_get_chunk_data(CarlaHostHandle handle, uint pluginId)

  1767. {

  1768.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, gNullCharPtr);

  1769. 

  1770.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1771.     {

  1772.         CARLA_SAFE_ASSERT_RETURN(plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS, gNullCharPtr);

  1773. 

  1774.         void* data = nullptr;

  1775.         const std::size_t dataSize(plugin->getChunkData(&data));

  1776.         CARLA_SAFE_ASSERT_RETURN(data != nullptr && dataSize > 0, gNullCharPtr);

  1777. 

  1778.         static CarlaString chunkData;

  1779. 

  1780.         chunkData = CarlaString::asBase64(data, static_cast<std::size_t>(dataSize));

  1781.         return chunkData.buffer();

  1782.     }

  1783. 

  1784.     return gNullCharPtr;

  1785. }

  1786. 

  1787. // --------------------------------------------------------------------------------------------------------------------

  1788. 

  1789. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1790. {

  1791.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1792. 

  1793.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1794.         return plugin->getParameterCount();

  1795. 

  1796.     return 0;

  1797. }

  1798. 

  1799. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1800. {

  1801.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1802. 

  1803.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1804.         return plugin->getProgramCount();

  1805. 

  1806.     return 0;

  1807. }

  1808. 

  1809. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1810. {

  1811.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1812. 

  1813.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1814.         return plugin->getMidiProgramCount();

  1815. 

  1816.     return 0;

  1817. }

  1818. 

  1819. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1820. {

  1821.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1822. 

  1823.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1824.         return plugin->getCustomDataCount();

  1825. 

  1826.     return 0;

  1827. }

  1828. 

  1829. // --------------------------------------------------------------------------------------------------------------------

  1830. 

  1831. const char* carla_get_parameter_text(CarlaHostHandle handle, uint pluginId, uint32_t parameterId)

  1832. {

  1833.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, gNullCharPtr);

  1834. 

  1835.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1836.     {

  1837.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), gNullCharPtr);

  1838. 

  1839.         static char textBuf[STR_MAX+1];

  1840.         carla_zeroChars(textBuf, STR_MAX+1);

  1841. 

  1842.         if (! plugin->getParameterText(parameterId, textBuf))

  1843.             textBuf[0] = '\0';

  1844. 

  1845.         return textBuf;

  1846.     }

  1847. 

  1848.     return gNullCharPtr;

  1849. }

  1850. 

  1851. const char* carla_get_program_name(CarlaHostHandle handle, uint pluginId, uint32_t programId)

  1852. {

  1853.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, nullptr);

  1854. 

  1855.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1856.     {

  1857.         CARLA_SAFE_ASSERT_RETURN(programId < plugin->getProgramCount(), gNullCharPtr);

  1858. 

  1859.         static char programName[STR_MAX+1];

  1860.         carla_zeroChars(programName, STR_MAX+1);

  1861. 

  1862.         if (! plugin->getProgramName(programId, programName))

  1863.             programName[0] = '\0';

  1864. 

  1865.         return programName;

  1866.     }

  1867. 

  1868.     return gNullCharPtr;

  1869. }

  1870. 

  1871. const char* carla_get_midi_program_name(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId)

  1872. {

  1873.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, gNullCharPtr);

  1874. 

  1875.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1876.     {

  1877.         CARLA_SAFE_ASSERT_RETURN(midiProgramId < plugin->getMidiProgramCount(), gNullCharPtr);

  1878. 

  1879.         static char midiProgramName[STR_MAX+1];

  1880.         carla_zeroChars(midiProgramName, STR_MAX+1);

  1881. 

  1882.         if (! plugin->getMidiProgramName(midiProgramId, midiProgramName))

  1883.             midiProgramName[0] = '\0';

  1884. 

  1885.         return midiProgramName;

  1886.     }

  1887. 

  1888.     return gNullCharPtr;

  1889. }

  1890. 

  1891. const char* carla_get_real_plugin_name(CarlaHostHandle handle, uint pluginId)

  1892. {

  1893.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, gNullCharPtr);

  1894. 

  1895.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1896.     {

  1897.         static char realPluginName[STR_MAX+1];

  1898.         carla_zeroChars(realPluginName, STR_MAX+1);

  1899. 

  1900.         if (! plugin->getRealName(realPluginName))

  1901.             realPluginName[0] = '\0';

  1902. 

  1903.         return realPluginName;

  1904.     }

  1905. 

  1906.     return gNullCharPtr;

  1907. }

  1908. 

  1909. // --------------------------------------------------------------------------------------------------------------------

  1910. 

  1911. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1912. {

  1913.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, -1);

  1914. 

  1915.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1916.         return plugin->getCurrentProgram();

  1917. 

  1918.     return -1;

  1919. }

  1920. 

  1921. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1922. {

  1923.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, -1);

  1924. 

  1925.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1926.         return plugin->getCurrentMidiProgram();

  1927. 

  1928.     return -1;

  1929. }

  1930. 

  1931. // --------------------------------------------------------------------------------------------------------------------

  1932. 

  1933. float carla_get_default_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId)

  1934. {

  1935.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0.0f);

  1936. 

  1937.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1938.     {

  1939.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), 0.0f);

  1940. 

  1941.         return plugin->getParameterRanges(parameterId).def;

  1942.     }

  1943. 

  1944.     return 0.0f;

  1945. }

  1946. 

  1947. float carla_get_current_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId)

  1948. {

  1949.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0.0f);

  1950. 

  1951.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1952.     {

  1953.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(), 0.0f);

  1954. 

  1955.         return plugin->getParameterValue(parameterId);

  1956.     }

  1957. 

  1958.     return 0.0f;

  1959. }

  1960. 

  1961. float carla_get_internal_parameter_value(CarlaHostHandle handle, uint pluginId, int32_t parameterId)

  1962. {

  1963. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1964.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, (parameterId == CB::PARAMETER_CTRL_CHANNEL) ? -1.0f : 0.0f);

  1965. #else

  1966.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0.0f);

  1967. #endif

  1968.     CARLA_SAFE_ASSERT_RETURN(parameterId != CB::PARAMETER_NULL && parameterId > CB::PARAMETER_MAX, 0.0f);

  1969. 

  1970.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1971.         return plugin->getInternalParameterValue(parameterId);

  1972. 

  1973.     return 0.0f;

  1974. }

  1975. 

  1976. // --------------------------------------------------------------------------------------------------------------------

  1977. 

  1978. uint32_t carla_get_plugin_latency(CarlaHostHandle handle, uint pluginId)

  1979. {

  1980.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  1981. 

  1982.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  1983.          return plugin->getLatencyInFrames();

  1984. 

  1985.     return 0;

  1986. }

  1987. 

  1988. // --------------------------------------------------------------------------------------------------------------------

  1989. 

  1990. const float* carla_get_peak_values(CarlaHostHandle handle, uint pluginId)

  1991. {

  1992.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, nullptr);

  1993. 

  1994.     return handle->engine->getPeaks(pluginId);

  1995. }

  1996. 

  1997. float carla_get_input_peak_value(CarlaHostHandle handle, uint pluginId, bool isLeft)

  1998. {

  1999.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0.0f);

  2000. 

  2001.     return handle->engine->getInputPeak(pluginId, isLeft);

  2002. }

  2003. 

  2004. float carla_get_output_peak_value(CarlaHostHandle handle, uint pluginId, bool isLeft)

  2005. {

  2006.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0.0f);

  2007. 

  2008.     return handle->engine->getOutputPeak(pluginId, isLeft);

  2009. }

  2010. 

  2011. // --------------------------------------------------------------------------------------------------------------------

  2012. 

  2013. CARLA_BACKEND_START_NAMESPACE

  2014. 

  2015. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2016. // defined in CarlaPluginInternal.cpp

  2017. const void* carla_render_inline_display_internal(const CarlaPluginPtr& plugin, uint32_t width, uint32_t height);

  2018. #endif

  2019. 

  2020. // defined in CarlaPluginLV2.cpp

  2021. const void* carla_render_inline_display_lv2(const CarlaPluginPtr& plugin, uint32_t width, uint32_t height);

  2022. 

  2023. CARLA_BACKEND_END_NAMESPACE

  2024. 

  2025. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  2026.                                                                   uint pluginId,

  2027.                                                                   uint32_t width, uint32_t height)

  2028. {

  2029.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(), nullptr);

  2030. 

  2031.     if (handle->engine->isAboutToClose())

  2032.         return nullptr;

  2033. 

  2034.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2035.     {

  2036.         switch (plugin->getType())

  2037.         {

  2038. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2039.         case CB::PLUGIN_INTERNAL:

  2040.             return (const CarlaInlineDisplayImageSurface*)CB::carla_render_inline_display_internal(plugin, width, height);

  2041. #endif

  2042.         case CB::PLUGIN_LV2:

  2043.             return (const CarlaInlineDisplayImageSurface*)CB::carla_render_inline_display_lv2(plugin, width, height);

  2044.         default:

  2045.             return nullptr;

  2046.         }

  2047.     }

  2048. 

  2049.     return nullptr;

  2050. }

  2051. 

  2052. // --------------------------------------------------------------------------------------------------------------------

  2053. 

  2054. void carla_set_active(CarlaHostHandle handle, uint pluginId, bool onOff)

  2055. {

  2056.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2057. 

  2058.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2059.         plugin->setActive(onOff, true, false);

  2060. }

  2061. 

  2062. #ifndef BUILD_BRIDGE

  2063. void carla_set_drywet(CarlaHostHandle handle, uint pluginId, float value)

  2064. {

  2065.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2066. 

  2067.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2068.         plugin->setDryWet(value, true, false);

  2069. }

  2070. 

  2071. void carla_set_volume(CarlaHostHandle handle, uint pluginId, float value)

  2072. {

  2073.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2074. 

  2075.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2076.         plugin->setVolume(value, true, false);

  2077. }

  2078. 

  2079. void carla_set_balance_left(CarlaHostHandle handle, uint pluginId, float value)

  2080. {

  2081.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2082. 

  2083.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2084.         plugin->setBalanceLeft(value, true, false);

  2085. }

  2086. 

  2087. void carla_set_balance_right(CarlaHostHandle handle, uint pluginId, float value)

  2088. {

  2089.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2090. 

  2091.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2092.         plugin->setBalanceRight(value, true, false);

  2093. }

  2094. 

  2095. void carla_set_panning(CarlaHostHandle handle, uint pluginId, float value)

  2096. {

  2097.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2098. 

  2099.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2100.         plugin->setPanning(value, true, false);

  2101. }

  2102. 

  2103. void carla_set_ctrl_channel(CarlaHostHandle handle, uint pluginId, int8_t channel)

  2104. {

  2105.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2106.     CARLA_SAFE_ASSERT_RETURN(channel >= -1 && channel < MAX_MIDI_CHANNELS,);

  2107. 

  2108.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2109.         plugin->setCtrlChannel(channel, true, false);

  2110. }

  2111. #endif

  2112. 

  2113. void carla_set_option(CarlaHostHandle handle, uint pluginId, uint option, bool yesNo)

  2114. {

  2115.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2116. 

  2117.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2118.         plugin->setOption(option, yesNo, false);

  2119. }

  2120. 

  2121. // --------------------------------------------------------------------------------------------------------------------

  2122. 

  2123. void carla_set_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, float value)

  2124. {

  2125.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2126. 

  2127.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2128.     {

  2129.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2130. 

  2131.         plugin->setParameterValue(parameterId, value, true, true, false);

  2132.     }

  2133. }

  2134. 

  2135. #ifndef BUILD_BRIDGE

  2136. 

  2137. void carla_set_parameter_midi_channel(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, uint8_t channel)

  2138. {

  2139.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2140.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2141. 

  2142.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2143.     {

  2144.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2145. 

  2146.         plugin->setParameterMidiChannel(parameterId, channel, true, false);

  2147.     }

  2148. }

  2149. 

  2150. void carla_set_parameter_mapped_control_index(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, int16_t index)

  2151. {

  2152.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2153.     CARLA_SAFE_ASSERT_RETURN(index >= CB::CONTROL_INDEX_NONE && index <= CB::CONTROL_INDEX_MAX_ALLOWED,);

  2154. 

  2155.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2156.     {

  2157.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2158. 

  2159.         plugin->setParameterMappedControlIndex(parameterId, index, true, false, true);

  2160.     }

  2161. }

  2162. 

  2163. void carla_set_parameter_mapped_range(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, float minimum, float maximum)

  2164. {

  2165.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2166. 

  2167.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2168.     {

  2169.         CARLA_SAFE_ASSERT_RETURN(parameterId < plugin->getParameterCount(),);

  2170. 

  2171.         plugin->setParameterMappedRange(parameterId, minimum, maximum, true, false);

  2172.     }

  2173. }

  2174. 

  2175. void carla_set_parameter_touch(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, bool touch)

  2176. {

  2177.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2178. 

  2179.     carla_debug("carla_set_parameter_touch(%p, %i, %i, %s)", handle, pluginId, parameterId, bool2str(touch));

  2180.     return handle->engine->touchPluginParameter(pluginId, parameterId, touch);

  2181. }

  2182. #endif

  2183. 

  2184. // --------------------------------------------------------------------------------------------------------------------

  2185. 

  2186. void carla_set_program(CarlaHostHandle handle, uint pluginId, uint32_t programId)

  2187. {

  2188.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2189. 

  2190.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2191.     {

  2192.         CARLA_SAFE_ASSERT_RETURN(programId < plugin->getProgramCount(),);

  2193. 

  2194.         plugin->setProgram(static_cast<int32_t>(programId), true, true, false);

  2195.     }

  2196. }

  2197. 

  2198. void carla_set_midi_program(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId)

  2199. {

  2200.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2201. 

  2202.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2203.     {

  2204.         CARLA_SAFE_ASSERT_RETURN(midiProgramId < plugin->getMidiProgramCount(),);

  2205. 

  2206.         plugin->setMidiProgram(static_cast<int32_t>(midiProgramId), true, true, false);

  2207.     }

  2208. }

  2209. 

  2210. // --------------------------------------------------------------------------------------------------------------------

  2211. 

  2212. void carla_set_custom_data(CarlaHostHandle handle, uint pluginId, const char* type, const char* key, const char* value)

  2213. {

  2214.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2215.     CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);

  2216.     CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);

  2217.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2218. 

  2219.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2220.         plugin->setCustomData(type, key, value, true);

  2221. }

  2222. 

  2223. void carla_set_chunk_data(CarlaHostHandle handle, uint pluginId, const char* chunkData)

  2224. {

  2225.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2226.     CARLA_SAFE_ASSERT_RETURN(chunkData != nullptr && chunkData[0] != '\0',);

  2227. 

  2228.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2229.     {

  2230.         CARLA_SAFE_ASSERT_RETURN(plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS,);

  2231. 

  2232.         std::vector<uint8_t> chunk(carla_getChunkFromBase64String(chunkData));

  2233. #ifdef CARLA_PROPER_CPP11_SUPPORT

  2234.         plugin->setChunkData(chunk.data(), chunk.size());

  2235. #else

  2236.         plugin->setChunkData(&chunk.front(), chunk.size());

  2237. #endif

  2238.     }

  2239. }

  2240. 

  2241. // --------------------------------------------------------------------------------------------------------------------

  2242. 

  2243. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2244. {

  2245.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2246. 

  2247.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2248.         plugin->prepareForSave(false);

  2249. }

  2250. 

  2251. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2252. {

  2253.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2254. 

  2255.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2256.         plugin->resetParameters();

  2257. }

  2258. 

  2259. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2260. {

  2261.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2262. 

  2263.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2264.         plugin->randomizeParameters();

  2265. }

  2266. 

  2267. #ifndef BUILD_BRIDGE

  2268. void carla_send_midi_note(CarlaHostHandle handle, uint pluginId, uint8_t channel, uint8_t note, uint8_t velocity)

  2269. {

  2270.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr && handle->engine->isRunning(),);

  2271. 

  2272.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2273.         plugin->sendMidiSingleNote(channel, note, velocity, true, true, false);

  2274. }

  2275. #endif

  2276. 

  2277. void carla_set_custom_ui_title(CarlaHostHandle handle, uint pluginId, const char* title)

  2278. {

  2279.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2280.     CARLA_SAFE_ASSERT_RETURN(title != nullptr,);

  2281. 

  2282.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2283.         plugin->setCustomUITitle(title);

  2284. }

  2285. 

  2286. void carla_show_custom_ui(CarlaHostHandle handle, uint pluginId, bool yesNo)

  2287. {

  2288.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr,);

  2289. 

  2290.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2291.         plugin->showCustomUI(yesNo);

  2292. }

  2293. 

  2294. void* carla_embed_custom_ui(CarlaHostHandle handle, uint pluginId, void* ptr)

  2295. {

  2296.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, nullptr);

  2297. 

  2298.     if (const CarlaPluginPtr plugin = handle->engine->getPlugin(pluginId))

  2299.         return plugin->embedCustomUI(ptr);

  2300. 

  2301.     return nullptr;

  2302. }

  2303. 

  2304. // --------------------------------------------------------------------------------------------------------------------

  2305. 

  2306. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2307. {

  2308.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0);

  2309. 

  2310.     carla_debug("carla_get_buffer_size(%p)", handle);

  2311.     return handle->engine->getBufferSize();

  2312. }

  2313. 

  2314. double carla_get_sample_rate(CarlaHostHandle handle)

  2315. {

  2316.     CARLA_SAFE_ASSERT_RETURN(handle->engine != nullptr, 0.0);

  2317. 

  2318.     carla_debug("carla_get_sample_rate(%p)", handle);

  2319.     return handle->engine->getSampleRate();

  2320. }

  2321. 

  2322. // --------------------------------------------------------------------------------------------------------------------

  2323. 

  2324. const char* carla_get_last_error(CarlaHostHandle handle)

  2325. {

  2326.     carla_debug("carla_get_last_error(%p)", handle);

  2327. 

  2328.     if (handle->engine != nullptr)

  2329.         return handle->engine->getLastError();

  2330. 

  2331.     return handle->isStandalone

  2332.            ? ((CarlaHostStandalone*)handle)->lastError.buffer()

  2333.            : gNullCharPtr;

  2334. }

  2335. 

  2336. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2337. {

  2338.     carla_debug("carla_get_host_osc_url_tcp(%p)", handle);

  2339. 

  2340. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2341.     if (handle->engine == nullptr)

  2342.     {

  2343.         carla_stderr2("carla_get_host_osc_url_tcp() failed, engine is not running");

  2344.         if (handle->isStandalone)

  2345.             ((CarlaHostStandalone*)handle)->lastError = "Engine is not running";

  2346.         return gNullCharPtr;

  2347.     }

  2348. 

  2349.     const char* const path = handle->engine->getOscServerPathTCP();

  2350. 

  2351.     if (path != nullptr && path[0] != '\0')

  2352.         return path;

  2353. 

  2354.     static const char* const notAvailable = "(OSC TCP port not available)";

  2355.     return notAvailable;

  2356. #else

  2357.     return "(OSC support not available in this build)";

  2358. 

  2359.     // unused

  2360.     (void)handle;

  2361. #endif

  2362. }

  2363. 

  2364. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2365. {

  2366.     carla_debug("carla_get_host_osc_url_udp(%p)", handle);

  2367. 

  2368. #if defined(HAVE_LIBLO) && !defined(BUILD_BRIDGE)

  2369.     if (handle->engine == nullptr)

  2370.     {

  2371.         carla_stderr2("carla_get_host_osc_url_udp() failed, engine is not running");

  2372.         if (handle->isStandalone)

  2373.             ((CarlaHostStandalone*)handle)->lastError = "Engine is not running";

  2374.         return gNullCharPtr;

  2375.     }

  2376. 

  2377.     const char* const path = handle->engine->getOscServerPathUDP();

  2378. 

  2379.     if (path != nullptr && path[0] != '\0')

  2380.         return path;

  2381. 

  2382.     static const char* const notAvailable = "(OSC UDP port not available)";

  2383.     return notAvailable;

  2384. #else

  2385.     return "(OSC support not available in this build)";

  2386. 

  2387.     // unused

  2388.     (void)handle;

  2389. #endif

  2390. }

  2391. 

  2392. // --------------------------------------------------------------------------------------------------------------------

  2393. 

  2394. #ifndef CARLA_PLUGIN_BUILD

  2395. # define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2396. # include "CarlaPluginUI.cpp"

  2397. # undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2398. # include "CarlaDssiUtils.cpp"

  2399. # include "CarlaMacUtils.cpp"

  2400. # include "CarlaPatchbayUtils.cpp"

  2401. # include "CarlaPipeUtils.cpp"

  2402. # include "CarlaProcessUtils.cpp"

  2403. # include "CarlaStateUtils.cpp"

  2404. # include "utils/Information.cpp"

  2405. # include "utils/Windows.cpp"

  2406. #endif /* CARLA_PLUGIN_BUILD */

  2407. 

  2408. // --------------------------------------------------------------------------------------------------------------------