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

2410 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. #ifndef BUILD_BRIDGE

  31. # include "CarlaLogThread.hpp"

  32. #endif

  33. 

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

  35. 

  36. #ifdef USING_JUCE

  37. # include "carla_juce/carla_juce.h"

  38. #endif

  39. 

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

  41.     if (! (cond)) {                                              \

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

  43.         if (handle->isStandalone)                                \

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

  45.         return ret;                                              \

  46.     }

  47. 

  48. // -------------------------------------------------------------------------------------------------------------------

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

  50. 

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

  52. 

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

  54. {

  55.     if (charPtr == nullptr)

  56.         charPtr = gNullCharPtr;

  57. }

  58. 

  59. // -------------------------------------------------------------------------------------------------------------------

  60. // Constructors

  61. 

  62. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  63.     : type(CB::PLUGIN_NONE),

  64.       category(CB::PLUGIN_CATEGORY_NONE),

  65.       hints(0x0),

  66.       optionsAvailable(0x0),

  67.       optionsEnabled(0x0),

  68.       filename(gNullCharPtr),

  69.       name(gNullCharPtr),

  70.       label(gNullCharPtr),

  71.       maker(gNullCharPtr),

  72.       copyright(gNullCharPtr),

  73.       iconName(gNullCharPtr),

  74.       uniqueId(0) {}

  75. 

  76. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  77. {

  78.     if (label != gNullCharPtr)

  79.         delete[] label;

  80.     if (maker != gNullCharPtr)

  81.         delete[] maker;

  82.     if (copyright != gNullCharPtr)

  83.         delete[] copyright;

  84. }

  85. 

  86. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  87.     : name(gNullCharPtr),

  88.       symbol(gNullCharPtr),

  89.       unit(gNullCharPtr),

  90.       comment(gNullCharPtr),

  91.       groupName(gNullCharPtr),

  92.       scalePointCount(0) {}

  93. 

  94. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  95. {

  96.     if (name != gNullCharPtr)

  97.         delete[] name;

  98.     if (symbol != gNullCharPtr)

  99.         delete[] symbol;

  100.     if (unit != gNullCharPtr)

  101.         delete[] unit;

  102.     if (comment != gNullCharPtr)

  103.         delete[] comment;

  104.     if (groupName != gNullCharPtr)

  105.         delete[] groupName;

  106. }

  107. 

  108. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  109.     : value(0.0f),

  110.       label(gNullCharPtr) {}

  111. 

  112. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  113. {

  114.     if (label != gNullCharPtr)

  115.         delete[] label;

  116. }

  117. 

  118. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  119.     : playing(false),

  120.       frame(0),

  121.       bar(0),

  122.       beat(0),

  123.       tick(0),

  124.       bpm(0.0) {}

  125. 

  126. void _CarlaTransportInfo::clear() noexcept

  127. {

  128.     playing = false;

  129.     frame = 0;

  130.     bar = 0;

  131.     beat = 0;

  132.     tick = 0;

  133.     bpm = 0.0;

  134. }

  135. 

  136. // --------------------------------------------------------------------------------------------------------------------

  137. 

  138. using CARLA_BACKEND_NAMESPACE::CarlaPluginPtr;

  139. 

  140. // --------------------------------------------------------------------------------------------------------------------

  141. 

  142. uint carla_get_engine_driver_count()

  143. {

  144.     carla_debug("carla_get_engine_driver_count()");

  145. 

  146.     return CarlaEngine::getDriverCount();

  147. }

  148. 

  149. const char* carla_get_engine_driver_name(uint index)

  150. {

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

  152. 

  153.     return CarlaEngine::getDriverName(index);

  154. }

  155. 

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

  157. {

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

  159. 

  160.     return CarlaEngine::getDriverDeviceNames(index);

  161. }

  162. 

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

  164. {

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

  166. 

  167.     static EngineDriverDeviceInfo retDevInfo;

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

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

  170. 

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

  172. 

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

  174.     {

  175.         retDevInfo.hints       =  devInfo->hints;

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

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

  178.     }

  179.     else

  180.     {

  181.         retDevInfo.hints       = 0x0;

  182.         retDevInfo.bufferSizes = nullBufferSizes;

  183.         retDevInfo.sampleRates = nullSampleRates;

  184.     }

  185. 

  186.     return &retDevInfo;

  187. }

  188. 

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

  190. {

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

  192. }

  193. 

  194. // --------------------------------------------------------------------------------------------------------------------

  195. 

  196. CarlaHostHandle carla_standalone_host_init(void)

  197. {

  198. #ifdef CARLA_OS_UNIX

  199.     static const ThreadSafeFFTW sThreadSafeFFTW;

  200. #endif

  201. 

  202.     static CarlaHostStandalone gStandalone;

  203. 

  204.     return &gStandalone;

  205. }

  206. 

  207. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  208. {

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

  210. 

  211.     return handle->engine;

  212. }

  213. 

  214. // --------------------------------------------------------------------------------------------------------------------

  215. 

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

  217. {

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

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

  220. 

  221.     using water::File;

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

  223. 

  224. #ifdef BUILD_BRIDGE

  225.     /*

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

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

  228. 

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

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

  231. 

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

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

  234.     */

  235. 

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

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

  238. 

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

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

  241. 

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

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

  244. 

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

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

  247. 

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

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

  250. 

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

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

  253. 

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

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

  256. 

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

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

  259. 

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

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

  262. 

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

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

  265. 

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

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

  268. 

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

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

  271. 

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

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

  274. 

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

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

  277. 

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

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

  280.     else

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

  282. 

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

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

  285.     else

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

  287. 

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

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

  290. 

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

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

  293. #else

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

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

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

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

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

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

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

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

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

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

  304. 

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

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

  307. 

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

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

  310. 

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

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

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

  314. 

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

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

  317. 

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

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

  320. 

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

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

  323. 

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

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

  326. 

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

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

  329. 

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

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

  332. 

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

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

  335. 

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

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

  338. 

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

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

  341. 

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

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

  344. 

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

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

  347.     else

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

  349. 

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

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

  352. 

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

  354. 

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

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

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

  358. 

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

  360.     {

  361.         char strBuf[STR_MAX+1];

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

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

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

  365.     }

  366.     else

  367.     {

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

  369.     }

  370. 

  371. # ifndef CARLA_OS_WIN

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

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

  374. 

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

  376. 

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

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

  379. 

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

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

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

  383. # endif

  384. 

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

  386. 

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

  388. #endif // BUILD_BRIDGE

  389. }

  390. 

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

  392. {

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

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

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

  396. 

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

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

  399. 

  400. #ifdef CARLA_OS_WIN

  401.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  402. #endif

  403. 

  404. #ifdef USING_JUCE

  405.     CarlaJUCE::initialiseJuce_GUI();

  406. #endif

  407. 

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

  409. 

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

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

  412. 

  413.     shandle.engine = engine;

  414. 

  415. #ifdef BUILD_BRIDGE

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

  417.     {

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

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

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

  421. 

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

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

  424.     }

  425.     else

  426.     {

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

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

  429.     }

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

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

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

  433. #else

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

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

  436. #endif

  437. 

  438.     carla_engine_init_common(shandle, engine);

  439. 

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

  441.     {

  442. #ifndef BUILD_BRIDGE

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

  444.             shandle.logThread.init();

  445. #endif

  446.         shandle.lastError = "No error";

  447.         return true;

  448.     }

  449.     else

  450.     {

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

  452.         shandle.engine = nullptr;

  453.         delete engine;

  454. #ifdef USING_JUCE

  455.         CarlaJUCE::shutdownJuce_GUI();

  456. #endif

  457.         return false;

  458.     }

  459. }

  460. 

  461. #ifdef BUILD_BRIDGE

  462. bool carla_engine_init_bridge(CarlaHostHandle handle,

  463.                               const char audioBaseName[6+1],

  464.                               const char rtClientBaseName[6+1],

  465.                               const char nonRtClientBaseName[6+1],

  466.                               const char nonRtServerBaseName[6+1],

  467.                               const char* const clientName)

  468. {

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

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

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

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

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

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

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

  476. 

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

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

  479. 

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

  481.                                                                      rtClientBaseName,

  482.                                                                      nonRtClientBaseName,

  483.                                                                      nonRtServerBaseName));

  484. 

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

  486. 

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

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

  489. 

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

  491. 

  492.     carla_engine_init_common(shandle, engine);

  493. 

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

  495.     {

  496.         shandle.lastError = "No error";

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

  498.         return true;

  499.     }

  500.     else

  501.     {

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

  503.         return false;

  504.     }

  505. }

  506. #endif

  507. 

  508. bool carla_engine_close(CarlaHostHandle handle)

  509. {

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

  511. 

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

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

  514. 

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

  516. 

  517.     CarlaEngine* const engine = shandle.engine;

  518. 

  519.     engine->setAboutToClose();

  520.     engine->removeAllPlugins();

  521. 

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

  523. 

  524.     if (! closed)

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

  526. 

  527. #ifndef BUILD_BRIDGE

  528.     shandle.logThread.stop();

  529. #endif

  530. 

  531.     shandle.engine = nullptr;

  532.     delete engine;

  533. 

  534. #ifdef USING_JUCE

  535.     CarlaJUCE::shutdownJuce_GUI();

  536. #endif

  537.     return closed;

  538. }

  539. 

  540. void carla_engine_idle(CarlaHostHandle handle)

  541. {

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

  543. 

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

  545. 

  546. #ifdef USING_JUCE

  547.     if (handle->isStandalone)

  548.         CarlaJUCE::idleJuce_GUI();

  549. #endif

  550. }

  551. 

  552. bool carla_is_engine_running(CarlaHostHandle handle)

  553. {

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

  555. }

  556. 

  557. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  558. {

  559.     static CarlaRuntimeEngineInfo retInfo;

  560. 

  561.     // reset

  562.     retInfo.load = 0.0f;

  563.     retInfo.xruns = 0;

  564. 

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

  566. 

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

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

  569. 

  570.     return &retInfo;

  571. }

  572. 

  573. #ifndef BUILD_BRIDGE

  574. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  575. {

  576.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  577. 

  578.     // reset

  579.     retInfo.name = gNullCharPtr;

  580.     retInfo.hints = 0x0;

  581.     retInfo.bufferSize = 0;

  582.     retInfo.bufferSizes = nullptr;

  583.     retInfo.sampleRate = 0.0;

  584.     retInfo.sampleRates = nullptr;

  585. 

  586.     const char* audioDriver;

  587.     const char* audioDevice;

  588. 

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

  590.     {

  591.         audioDriver = engine->getCurrentDriverName();

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

  593. 

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

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

  596.     }

  597.     else if (handle->isStandalone)

  598.     {

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

  600. 

  601.         audioDriver = shandle.engineOptions.audioDriver;

  602.         audioDevice = shandle.engineOptions.audioDevice;

  603. 

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

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

  606.     }

  607.     else

  608.     {

  609.         return &retInfo;

  610.     }

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

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

  613. 

  614.     uint index = 0;

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

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

  617.     {

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

  619.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  620. 

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

  622.             break;

  623.     }

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

  625. 

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

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

  628. 

  629.     retInfo.name        = audioDevice;

  630.     retInfo.hints       = devInfo->hints;

  631.     retInfo.bufferSizes = devInfo->bufferSizes;

  632.     retInfo.sampleRates = devInfo->sampleRates;

  633. 

  634.     return &retInfo;

  635. }

  636. 

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

  638. {

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

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

  641. 

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

  643. }

  644. 

  645. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  646. {

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

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

  649. 

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

  651. }

  652. #endif // BUILD_BRIDGE

  653. 

  654. void carla_clear_engine_xruns(CarlaHostHandle handle)

  655. {

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

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

  658. }

  659. 

  660. void carla_cancel_engine_action(CarlaHostHandle handle)

  661. {

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

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

  664. }

  665. 

  666. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  667. {

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

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

  670. 

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

  672. }

  673. 

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

  675. {

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

  677. 

  678.     if (handle->isStandalone)

  679.     {

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

  681. 

  682.         shandle.engineCallback    = func;

  683.         shandle.engineCallbackPtr = ptr;

  684. 

  685. #ifndef BUILD_BRIDGE

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

  687. #endif

  688.     }

  689. 

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

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

  692. }

  693. 

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

  695. {

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

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

  698. 

  699.     if (handle->isStandalone)

  700.     {

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

  702. 

  703.         switch (option)

  704.         {

  705.         case CB::ENGINE_OPTION_DEBUG:

  706.             break;

  707. 

  708.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  711.             break;

  712. 

  713.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  715. 

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

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

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

  719.             {

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

  721. 

  722.                 if (shandle.engineCallback != nullptr)

  723.                     shandle.engineCallback(shandle.engineCallbackPtr,

  724.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  725.                                            0,

  726.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  727.                                            0, 0, 0.0f,

  728.                                            shandle.engineOptions.transportExtra);

  729.             }

  730.             else

  731.             {

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

  733.             }

  734. 

  735.             delete[] shandle.engineOptions.transportExtra;

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

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

  738.             else

  739.                 shandle.engineOptions.transportExtra = nullptr;

  740.             break;

  741. 

  742.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  745.             break;

  746. 

  747.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  750.             break;

  751. 

  752.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  755.             break;

  756. 

  757.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  760.             break;

  761. 

  762.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  763.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  765.             break;

  766. 

  767.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  770.             break;

  771. 

  772.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  773.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  775.             break;

  776. 

  777.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  778.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  780.             break;

  781. 

  782.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  783.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  785.             break;

  786. 

  787.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  790.             break;

  791. 

  792.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  793.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  794. 

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

  796.                 delete[] shandle.engineOptions.audioDriver;

  797. 

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

  799.             break;

  800. 

  801.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  802.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  803. 

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

  805.                 delete[] shandle.engineOptions.audioDevice;

  806. 

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

  808.             break;

  809. 

  810. #ifndef BUILD_BRIDGE

  811.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  814.             break;

  815. 

  816.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  818.             shandle.engineOptions.oscPortTCP = value;

  819.             break;

  820. 

  821.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  823.             shandle.engineOptions.oscPortUDP = value;

  824.             break;

  825. #endif

  826. 

  827.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  830.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  831. 

  832.             switch (value)

  833.             {

  834.             case CB::FILE_AUDIO:

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

  836.                     delete[] shandle.engineOptions.pathAudio;

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

  838.                 break;

  839.             case CB::FILE_MIDI:

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

  841.                     delete[] shandle.engineOptions.pathMIDI;

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

  843.                 break;

  844.             }

  845.             break;

  846. 

  847.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  850.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  851. 

  852.             switch (value)

  853.             {

  854.             case CB::PLUGIN_LADSPA:

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

  856.                     delete[] shandle.engineOptions.pathLADSPA;

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

  858.                 break;

  859.             case CB::PLUGIN_DSSI:

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

  861.                     delete[] shandle.engineOptions.pathDSSI;

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

  863.                 break;

  864.             case CB::PLUGIN_LV2:

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

  866.                     delete[] shandle.engineOptions.pathLV2;

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

  868.                 break;

  869.             case CB::PLUGIN_VST2:

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

  871.                     delete[] shandle.engineOptions.pathVST2;

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

  873.                 break;

  874.             case CB::PLUGIN_VST3:

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

  876.                     delete[] shandle.engineOptions.pathVST3;

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

  878.                 break;

  879.             case CB::PLUGIN_SF2:

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

  881.                     delete[] shandle.engineOptions.pathSF2;

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

  883.                 break;

  884.             case CB::PLUGIN_SFZ:

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

  886.                     delete[] shandle.engineOptions.pathSFZ;

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

  888.                 break;

  889.             case CB::PLUGIN_JSFX:

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

  891.                     delete[] shandle.engineOptions.pathJSFX;

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

  893.                 break;

  894.             }

  895.             break;

  896. 

  897.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  899. 

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

  901.                 delete[] shandle.engineOptions.binaryDir;

  902. 

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

  904.             break;

  905. 

  906.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  908. 

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

  910.                 delete[] shandle.engineOptions.resourceDir;

  911. 

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

  913.             break;

  914. 

  915.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  918.             break;

  919. 

  920.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  922.             break;

  923. 

  924.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  926.             break;

  927. 

  928.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  929.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  931.             break;

  932. 

  933.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  936.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  938.         }   break;

  939. 

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

  941.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  943. 

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

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

  946. 

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

  948.             break;

  949. 

  950.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  953.             break;

  954. 

  955.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  957. 

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

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

  960. 

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

  962.             break;

  963. 

  964.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  967.             break;

  968. 

  969.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  972.             break;

  973. 

  974.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  977.             break;

  978. #endif

  979. 

  980. #ifndef BUILD_BRIDGE

  981.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  983.             break;

  984. #endif

  985. 

  986.         case CB::ENGINE_OPTION_CLIENT_NAME_PREFIX:

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

  988.                 delete[] shandle.engineOptions.clientNamePrefix;

  989. 

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

  991.                                                    ? carla_strdup_safe(valueStr)

  992.                                                    : nullptr;

  993.             break;

  994. 

  995.         case CB::ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

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

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

  998.             break;

  999.         }

  1000.     }

  1001. 

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

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

  1004. }

  1005. 

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

  1007. {

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

  1009. 

  1010.     if (handle->isStandalone)

  1011.     {

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

  1013. 

  1014.         shandle.fileCallback    = func;

  1015.         shandle.fileCallbackPtr = ptr;

  1016.     }

  1017. 

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

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

  1020. }

  1021. 

  1022. // --------------------------------------------------------------------------------------------------------------------

  1023. 

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

  1025. {

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

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

  1028. 

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

  1030. 

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

  1032. }

  1033. 

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

  1035. {

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

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

  1038. 

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

  1040. 

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

  1042. }

  1043. 

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

  1045. {

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

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

  1048. 

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

  1050. 

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

  1052. }

  1053. 

  1054. #ifndef BUILD_BRIDGE

  1055. const char* carla_get_current_project_folder(CarlaHostHandle handle)

  1056. {

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

  1058. 

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

  1060. 

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

  1062.         return ret;

  1063. 

  1064.     return gNullCharPtr;

  1065. }

  1066. 

  1067. const char* carla_get_current_project_filename(CarlaHostHandle handle)

  1068. {

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

  1070. 

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

  1072. 

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

  1074.         return ret;

  1075. 

  1076.     return gNullCharPtr;

  1077. }

  1078. 

  1079. void carla_clear_project_filename(CarlaHostHandle handle)

  1080. {

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

  1082. 

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

  1084. 

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

  1086. }

  1087. 

  1088. // --------------------------------------------------------------------------------------------------------------------

  1089. 

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

  1091. {

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

  1093. 

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

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

  1096. 

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

  1098. }

  1099. 

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

  1101. {

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

  1103. 

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

  1105. 

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

  1107. }

  1108. 

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

  1110. {

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

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

  1113. 

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

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

  1116. 

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

  1118.         return true;

  1119. 

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

  1121. }

  1122. 

  1123. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  1124. {

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

  1126. 

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

  1128. 

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

  1130. }

  1131. 

  1132. // --------------------------------------------------------------------------------------------------------------------

  1133. 

  1134. void carla_transport_play(CarlaHostHandle handle)

  1135. {

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

  1137. 

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

  1139. 

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

  1141. }

  1142. 

  1143. void carla_transport_pause(CarlaHostHandle handle)

  1144. {

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

  1146. 

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

  1148. 

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

  1150. }

  1151. 

  1152. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1153. {

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

  1155. 

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

  1157. 

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

  1159. }

  1160. 

  1161. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1162. {

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

  1164. 

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

  1166. 

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

  1168. }

  1169. 

  1170. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1171. {

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

  1173. 

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

  1175. }

  1176. 

  1177. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1178. {

  1179.     static CarlaTransportInfo retTransInfo;

  1180.     retTransInfo.clear();

  1181. 

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

  1183. 

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

  1185. 

  1186.     retTransInfo.playing = timeInfo.playing;

  1187.     retTransInfo.frame   = timeInfo.frame;

  1188. 

  1189.     if (timeInfo.bbt.valid)

  1190.     {

  1191.         retTransInfo.bar  = timeInfo.bbt.bar;

  1192.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1195.     }

  1196. 

  1197.     return &retTransInfo;

  1198. }

  1199. #endif

  1200. 

  1201. // --------------------------------------------------------------------------------------------------------------------

  1202. 

  1203. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1204. {

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

  1206. 

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

  1208. 

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

  1210. }

  1211. 

  1212. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1213. {

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

  1215. 

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

  1217. 

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

  1219. }

  1220. 

  1221. // --------------------------------------------------------------------------------------------------------------------

  1222. 

  1223. bool carla_add_plugin(CarlaHostHandle handle,

  1224.                       BinaryType btype, PluginType ptype,

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

  1226.                       const void* extraPtr, uint options)

  1227. {

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

  1229. 

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

  1231.                 handle,

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

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

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

  1235. 

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

  1237. }

  1238. 

  1239. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1240. {

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

  1242. 

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

  1244. 

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

  1246. }

  1247. 

  1248. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1249. {

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

  1251. 

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

  1253. 

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

  1255. }

  1256. 

  1257. #ifndef BUILD_BRIDGE

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

  1259. {

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

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

  1262. 

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

  1264. 

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

  1266. }

  1267. 

  1268. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1269. {

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

  1271. 

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

  1273. 

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

  1275. }

  1276. 

  1277. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1278. {

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

  1280. 

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

  1282. 

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

  1284. }

  1285. 

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

  1287. {

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

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

  1290. 

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

  1292. 

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

  1294. }

  1295. #endif

  1296. 

  1297. // --------------------------------------------------------------------------------------------------------------------

  1298. 

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

  1300. {

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

  1302.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1304. 

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

  1306.         return plugin->loadStateFromFile(filename);

  1307. 

  1308.     return false;

  1309. }

  1310. 

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

  1312. {

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

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

  1315. 

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

  1317.         return plugin->saveStateToFile(filename);

  1318. 

  1319.     return false;

  1320. }

  1321. 

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

  1323. {

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

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

  1326. 

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

  1328.         return plugin->exportAsLV2(lv2path);

  1329. 

  1330.     return false;

  1331. }

  1332. 

  1333. // --------------------------------------------------------------------------------------------------------------------

  1334. 

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

  1336. {

  1337.     static CarlaPluginInfo retInfo;

  1338. 

  1339.     // reset

  1340.     retInfo.type             = CB::PLUGIN_NONE;

  1341.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1342.     retInfo.hints            = 0x0;

  1343.     retInfo.optionsAvailable = 0x0;

  1344.     retInfo.optionsEnabled   = 0x0;

  1345.     retInfo.filename         = gNullCharPtr;

  1346.     retInfo.name             = gNullCharPtr;

  1347.     retInfo.iconName         = gNullCharPtr;

  1348.     retInfo.uniqueId         = 0;

  1349. 

  1350.     // cleanup

  1351.     if (retInfo.label != gNullCharPtr)

  1352.     {

  1353.         delete[] retInfo.label;

  1354.         retInfo.label = gNullCharPtr;

  1355.     }

  1356. 

  1357.     if (retInfo.maker != gNullCharPtr)

  1358.     {

  1359.         delete[] retInfo.maker;

  1360.         retInfo.maker = gNullCharPtr;

  1361.     }

  1362. 

  1363.     if (retInfo.copyright != gNullCharPtr)

  1364.     {

  1365.         delete[] retInfo.copyright;

  1366.         retInfo.copyright = gNullCharPtr;

  1367.     }

  1368. 

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

  1370. 

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

  1372.     {

  1373.         char strBuf[STR_MAX+1];

  1374.         carla_zeroChars(strBuf, STR_MAX+1);

  1375. 

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

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

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

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

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

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

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

  1383. 

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

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

  1386. 

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

  1388.             retInfo.label = carla_strdup_safe(strBuf);

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

  1390.             retInfo.maker = carla_strdup_safe(strBuf);

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

  1392.             retInfo.copyright = carla_strdup_safe(strBuf);

  1393. 

  1394.         checkStringPtr(retInfo.filename);

  1395.         checkStringPtr(retInfo.name);

  1396.         checkStringPtr(retInfo.iconName);

  1397.         checkStringPtr(retInfo.label);

  1398.         checkStringPtr(retInfo.maker);

  1399.         checkStringPtr(retInfo.copyright);

  1400.     }

  1401. 

  1402.     return &retInfo;

  1403. }

  1404. 

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

  1406. {

  1407.     static CarlaPortCountInfo retInfo;

  1408.     carla_zeroStruct(retInfo);

  1409. 

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

  1411. 

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

  1413.     {

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

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

  1416.     }

  1417. 

  1418.     return &retInfo;

  1419. }

  1420. 

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

  1422. {

  1423.     static CarlaPortCountInfo retInfo;

  1424.     carla_zeroStruct(retInfo);

  1425. 

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

  1427. 

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

  1429.     {

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

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

  1432.     }

  1433. 

  1434.     return &retInfo;

  1435. }

  1436. 

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

  1438. {

  1439.     static CarlaPortCountInfo retInfo;

  1440.     carla_zeroStruct(retInfo);

  1441. 

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

  1443. 

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

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

  1446. 

  1447.     return &retInfo;

  1448. }

  1449. 

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

  1451. {

  1452.     static CarlaParameterInfo retInfo;

  1453. 

  1454.     // reset

  1455.     retInfo.scalePointCount = 0;

  1456. 

  1457.     // cleanup

  1458.     if (retInfo.name != gNullCharPtr)

  1459.     {

  1460.         delete[] retInfo.name;

  1461.         retInfo.name = gNullCharPtr;

  1462.     }

  1463. 

  1464.     if (retInfo.symbol != gNullCharPtr)

  1465.     {

  1466.         delete[] retInfo.symbol;

  1467.         retInfo.symbol = gNullCharPtr;

  1468.     }

  1469. 

  1470.     if (retInfo.unit != gNullCharPtr)

  1471.     {

  1472.         delete[] retInfo.unit;

  1473.         retInfo.unit = gNullCharPtr;

  1474.     }

  1475. 

  1476.     if (retInfo.comment != gNullCharPtr)

  1477.     {

  1478.         delete[] retInfo.comment;

  1479.         retInfo.comment = gNullCharPtr;

  1480.     }

  1481. 

  1482.     if (retInfo.groupName != gNullCharPtr)

  1483.     {

  1484.         delete[] retInfo.groupName;

  1485.         retInfo.groupName = gNullCharPtr;

  1486.     }

  1487. 

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

  1489. 

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

  1491.     {

  1492.         char strBuf[STR_MAX+1];

  1493.         carla_zeroChars(strBuf, STR_MAX+1);

  1494. 

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

  1496. 

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

  1498.         {

  1499.             retInfo.name = carla_strdup_safe(strBuf);

  1500.             carla_zeroChars(strBuf, STR_MAX+1);

  1501.         }

  1502. 

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

  1504.         {

  1505.             retInfo.symbol = carla_strdup_safe(strBuf);

  1506.             carla_zeroChars(strBuf, STR_MAX+1);

  1507.         }

  1508. 

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

  1510.         {

  1511.             retInfo.unit = carla_strdup_safe(strBuf);

  1512.             carla_zeroChars(strBuf, STR_MAX+1);

  1513.         }

  1514. 

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

  1516.         {

  1517.             retInfo.comment = carla_strdup_safe(strBuf);

  1518.             carla_zeroChars(strBuf, STR_MAX+1);

  1519.         }

  1520. 

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

  1522.         {

  1523.             retInfo.groupName = carla_strdup_safe(strBuf);

  1524.             carla_zeroChars(strBuf, STR_MAX+1);

  1525.         }

  1526. 

  1527.         checkStringPtr(retInfo.name);

  1528.         checkStringPtr(retInfo.symbol);

  1529.         checkStringPtr(retInfo.unit);

  1530.         checkStringPtr(retInfo.comment);

  1531.         checkStringPtr(retInfo.groupName);

  1532.     }

  1533. 

  1534.     return &retInfo;

  1535. }

  1536. 

  1537. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1538.                                                                uint pluginId,

  1539.                                                                uint32_t parameterId,

  1540.                                                                uint32_t scalePointId)

  1541. {

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

  1543. 

  1544.     static CarlaScalePointInfo retInfo;

  1545. 

  1546.     // reset

  1547.     retInfo.value = 0.0f;

  1548. 

  1549.     // cleanup

  1550.     if (retInfo.label != gNullCharPtr)

  1551.     {

  1552.         delete[] retInfo.label;

  1553.         retInfo.label = gNullCharPtr;

  1554.     }

  1555. 

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

  1557. 

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

  1559.     {

  1560.         char strBuf[STR_MAX+1];

  1561. 

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

  1563. 

  1564.         carla_zeroChars(strBuf, STR_MAX+1);

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

  1566.             retInfo.label = carla_strdup_safe(strBuf);

  1567. 

  1568.         checkStringPtr(retInfo.label);

  1569.     }

  1570. 

  1571.     return &retInfo;

  1572. }

  1573. 

  1574. // --------------------------------------------------------------------------------------------------------------------

  1575. 

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

  1577. {

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

  1579. 

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

  1581.     {

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

  1583. 

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

  1585.     }

  1586. 

  1587.     return 0x0;

  1588. }

  1589. 

  1590. // --------------------------------------------------------------------------------------------------------------------

  1591. 

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

  1593. {

  1594.     static ParameterData retParamData;

  1595. 

  1596.     // reset

  1597.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1598.     retParamData.hints       = 0x0;

  1599.     retParamData.index       = CB::PARAMETER_NULL;

  1600.     retParamData.rindex      = -1;

  1601.     retParamData.midiChannel = 0;

  1602.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1603.     retParamData.mappedMinimum = 0.0f;

  1604.     retParamData.mappedMaximum = 0.0f;

  1605. 

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

  1607. 

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

  1609.     {

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

  1611. 

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

  1613.         retParamData.type        = pluginParamData.type;

  1614.         retParamData.hints       = pluginParamData.hints;

  1615.         retParamData.index       = pluginParamData.index;

  1616.         retParamData.rindex      = pluginParamData.rindex;

  1617.         retParamData.midiChannel = pluginParamData.midiChannel;

  1618.         retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1619.         retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1620.         retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1621.     }

  1622. 

  1623.     return &retParamData;

  1624. }

  1625. 

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

  1627. {

  1628.     static ParameterRanges retParamRanges;

  1629. 

  1630.     // reset

  1631.     retParamRanges.def       = 0.0f;

  1632.     retParamRanges.min       = 0.0f;

  1633.     retParamRanges.max       = 1.0f;

  1634.     retParamRanges.step      = 0.01f;

  1635.     retParamRanges.stepSmall = 0.0001f;

  1636.     retParamRanges.stepLarge = 0.1f;

  1637. 

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

  1639. 

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

  1641.     {

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

  1643. 

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

  1645.         retParamRanges.def       = pluginParamRanges.def;

  1646.         retParamRanges.min       = pluginParamRanges.min;

  1647.         retParamRanges.max       = pluginParamRanges.max;

  1648.         retParamRanges.step      = pluginParamRanges.step;

  1649.         retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1650.         retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1651.     }

  1652. 

  1653.     return &retParamRanges;

  1654. }

  1655. 

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

  1657. {

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

  1659. 

  1660.     // reset

  1661.     retMidiProgData.bank    = 0;

  1662.     retMidiProgData.program = 0;

  1663. 

  1664.     if (retMidiProgData.name != gNullCharPtr)

  1665.     {

  1666.         delete[] retMidiProgData.name;

  1667.         retMidiProgData.name = gNullCharPtr;

  1668.     }

  1669. 

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

  1671. 

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

  1673.     {

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

  1675. 

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

  1677.         retMidiProgData.bank    = pluginMidiProgData.bank;

  1678.         retMidiProgData.program = pluginMidiProgData.program;

  1679. 

  1680.         if (pluginMidiProgData.name != nullptr)

  1681.         {

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

  1683.             checkStringPtr(retMidiProgData.name);

  1684.         }

  1685.         else

  1686.         {

  1687.             retMidiProgData.name = gNullCharPtr;

  1688.         }

  1689.     }

  1690. 

  1691.     return &retMidiProgData;

  1692. }

  1693. 

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

  1695. {

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

  1697. 

  1698.     // reset

  1699.     if (retCustomData.type != gNullCharPtr)

  1700.     {

  1701.         delete[] retCustomData.type;

  1702.         retCustomData.type = gNullCharPtr;

  1703.     }

  1704. 

  1705.     if (retCustomData.key != gNullCharPtr)

  1706.     {

  1707.         delete[] retCustomData.key;

  1708.         retCustomData.key = gNullCharPtr;

  1709.     }

  1710. 

  1711.     if (retCustomData.value != gNullCharPtr)

  1712.     {

  1713.         delete[] retCustomData.value;

  1714.         retCustomData.value = gNullCharPtr;

  1715.     }

  1716. 

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

  1718. 

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

  1720.     {

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

  1722. 

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

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

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

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

  1727.         checkStringPtr(retCustomData.type);

  1728.         checkStringPtr(retCustomData.key);

  1729.         checkStringPtr(retCustomData.value);

  1730.     }

  1731. 

  1732.     return &retCustomData;

  1733. }

  1734. 

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

  1736. {

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

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

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

  1740. 

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

  1742.     {

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

  1744. 

  1745.         if (count == 0)

  1746.             return gNullCharPtr;

  1747. 

  1748.         static CarlaString customDataValue;

  1749. 

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

  1751.         {

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

  1753. 

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

  1755.                 continue;

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

  1757.                 continue;

  1758. 

  1759.             customDataValue = pluginCustomData.value;

  1760.             return customDataValue.buffer();

  1761.         }

  1762.     }

  1763. 

  1764.     return gNullCharPtr;

  1765. }

  1766. 

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

  1768. {

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

  1770. 

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

  1772.     {

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

  1774. 

  1775.         void* data = nullptr;

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

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

  1778. 

  1779.         static CarlaString chunkData;

  1780. 

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

  1782.         return chunkData.buffer();

  1783.     }

  1784. 

  1785.     return gNullCharPtr;

  1786. }

  1787. 

  1788. // --------------------------------------------------------------------------------------------------------------------

  1789. 

  1790. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1791. {

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

  1793. 

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

  1795.         return plugin->getParameterCount();

  1796. 

  1797.     return 0;

  1798. }

  1799. 

  1800. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1801. {

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

  1803. 

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

  1805.         return plugin->getProgramCount();

  1806. 

  1807.     return 0;

  1808. }

  1809. 

  1810. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1811. {

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

  1813. 

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

  1815.         return plugin->getMidiProgramCount();

  1816. 

  1817.     return 0;

  1818. }

  1819. 

  1820. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1821. {

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

  1823. 

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

  1825.         return plugin->getCustomDataCount();

  1826. 

  1827.     return 0;

  1828. }

  1829. 

  1830. // --------------------------------------------------------------------------------------------------------------------

  1831. 

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

  1833. {

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

  1835. 

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

  1837.     {

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

  1839. 

  1840.         static char textBuf[STR_MAX+1];

  1841.         carla_zeroChars(textBuf, STR_MAX+1);

  1842. 

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

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

  1845. 

  1846.         return textBuf;

  1847.     }

  1848. 

  1849.     return gNullCharPtr;

  1850. }

  1851. 

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

  1853. {

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

  1855. 

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

  1857.     {

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

  1859. 

  1860.         static char programName[STR_MAX+1];

  1861.         carla_zeroChars(programName, STR_MAX+1);

  1862. 

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

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

  1865. 

  1866.         return programName;

  1867.     }

  1868. 

  1869.     return gNullCharPtr;

  1870. }

  1871. 

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

  1873. {

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

  1875. 

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

  1877.     {

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

  1879. 

  1880.         static char midiProgramName[STR_MAX+1];

  1881.         carla_zeroChars(midiProgramName, STR_MAX+1);

  1882. 

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

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

  1885. 

  1886.         return midiProgramName;

  1887.     }

  1888. 

  1889.     return gNullCharPtr;

  1890. }

  1891. 

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

  1893. {

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

  1895. 

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

  1897.     {

  1898.         static char realPluginName[STR_MAX+1];

  1899.         carla_zeroChars(realPluginName, STR_MAX+1);

  1900. 

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

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

  1903. 

  1904.         return realPluginName;

  1905.     }

  1906. 

  1907.     return gNullCharPtr;

  1908. }

  1909. 

  1910. // --------------------------------------------------------------------------------------------------------------------

  1911. 

  1912. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1913. {

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

  1915. 

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

  1917.         return plugin->getCurrentProgram();

  1918. 

  1919.     return -1;

  1920. }

  1921. 

  1922. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1923. {

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

  1925. 

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

  1927.         return plugin->getCurrentMidiProgram();

  1928. 

  1929.     return -1;

  1930. }

  1931. 

  1932. // --------------------------------------------------------------------------------------------------------------------

  1933. 

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

  1935. {

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

  1937. 

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

  1939.     {

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

  1941. 

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

  1943.     }

  1944. 

  1945.     return 0.0f;

  1946. }

  1947. 

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

  1949. {

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

  1951. 

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

  1953.     {

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

  1955. 

  1956.         return plugin->getParameterValue(parameterId);

  1957.     }

  1958. 

  1959.     return 0.0f;

  1960. }

  1961. 

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

  1963. {

  1964. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1966. #else

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

  1968. #endif

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

  1970. 

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

  1972.         return plugin->getInternalParameterValue(parameterId);

  1973. 

  1974.     return 0.0f;

  1975. }

  1976. 

  1977. // --------------------------------------------------------------------------------------------------------------------

  1978. 

  1979. uint32_t carla_get_plugin_latency(CarlaHostHandle handle, uint pluginId)

  1980. {

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

  1982. 

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

  1984.          return plugin->getLatencyInFrames();

  1985. 

  1986.     return 0;

  1987. }

  1988. 

  1989. // --------------------------------------------------------------------------------------------------------------------

  1990. 

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

  1992. {

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

  1994. 

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

  1996. }

  1997. 

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

  1999. {

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

  2001. 

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

  2003. }

  2004. 

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

  2006. {

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

  2008. 

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

  2010. }

  2011. 

  2012. // --------------------------------------------------------------------------------------------------------------------

  2013. 

  2014. CARLA_BACKEND_START_NAMESPACE

  2015. 

  2016. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2017. // defined in CarlaPluginInternal.cpp

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

  2019. #endif

  2020. 

  2021. // defined in CarlaPluginLV2.cpp

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

  2023. 

  2024. CARLA_BACKEND_END_NAMESPACE

  2025. 

  2026. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  2027.                                                                   uint pluginId,

  2028.                                                                   uint32_t width, uint32_t height)

  2029. {

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

  2031. 

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

  2033.         return nullptr;

  2034. 

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

  2036.     {

  2037.         switch (plugin->getType())

  2038.         {

  2039. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2040.         case CB::PLUGIN_INTERNAL:

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

  2042. #endif

  2043.         case CB::PLUGIN_LV2:

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

  2045.         default:

  2046.             return nullptr;

  2047.         }

  2048.     }

  2049. 

  2050.     return nullptr;

  2051. }

  2052. 

  2053. // --------------------------------------------------------------------------------------------------------------------

  2054. 

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

  2056. {

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

  2058. 

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

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

  2061. }

  2062. 

  2063. #ifndef BUILD_BRIDGE

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

  2065. {

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

  2067. 

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

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

  2070. }

  2071. 

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

  2073. {

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

  2075. 

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

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

  2078. }

  2079. 

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

  2081. {

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

  2083. 

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

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

  2086. }

  2087. 

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

  2089. {

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

  2091. 

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

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

  2094. }

  2095. 

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

  2097. {

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

  2099. 

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

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

  2102. }

  2103. 

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

  2105. {

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

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

  2108. 

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

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

  2111. }

  2112. #endif

  2113. 

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

  2115. {

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

  2117. 

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

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

  2120. }

  2121. 

  2122. // --------------------------------------------------------------------------------------------------------------------

  2123. 

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

  2125. {

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

  2127. 

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

  2129.     {

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

  2131. 

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

  2133.     }

  2134. }

  2135. 

  2136. #ifndef BUILD_BRIDGE

  2137. 

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

  2139. {

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

  2141.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2142. 

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

  2144.     {

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

  2146. 

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

  2148.     }

  2149. }

  2150. 

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

  2152. {

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

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

  2155. 

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

  2157.     {

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

  2159. 

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

  2161.     }

  2162. }

  2163. 

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

  2165. {

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

  2167. 

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

  2169.     {

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

  2171. 

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

  2173.     }

  2174. }

  2175. 

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

  2177. {

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

  2179. 

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

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

  2182. }

  2183. #endif

  2184. 

  2185. // --------------------------------------------------------------------------------------------------------------------

  2186. 

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

  2188. {

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

  2190. 

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

  2192.     {

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

  2194. 

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

  2196.     }

  2197. }

  2198. 

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

  2200. {

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

  2202. 

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

  2204.     {

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

  2206. 

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

  2208.     }

  2209. }

  2210. 

  2211. // --------------------------------------------------------------------------------------------------------------------

  2212. 

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

  2214. {

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

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

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

  2218.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2219. 

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

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

  2222. }

  2223. 

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

  2225. {

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

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

  2228. 

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

  2230.     {

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

  2232. 

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

  2234. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2236. #else

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

  2238. #endif

  2239.     }

  2240. }

  2241. 

  2242. // --------------------------------------------------------------------------------------------------------------------

  2243. 

  2244. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2245. {

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

  2247. 

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

  2249.         plugin->prepareForSave(false);

  2250. }

  2251. 

  2252. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2253. {

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

  2255. 

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

  2257.         plugin->resetParameters();

  2258. }

  2259. 

  2260. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2261. {

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

  2263. 

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

  2265.         plugin->randomizeParameters();

  2266. }

  2267. 

  2268. #ifndef BUILD_BRIDGE

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

  2270. {

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

  2272. 

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

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

  2275. }

  2276. #endif

  2277. 

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

  2279. {

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

  2281.     CARLA_SAFE_ASSERT_RETURN(title != nullptr,);

  2282. 

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

  2284.         plugin->setCustomUITitle(title);

  2285. }

  2286. 

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

  2288. {

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

  2290. 

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

  2292.         plugin->showCustomUI(yesNo);

  2293. }

  2294. 

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

  2296. {

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

  2298. 

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

  2300.         return plugin->embedCustomUI(ptr);

  2301. 

  2302.     return nullptr;

  2303. }

  2304. 

  2305. // --------------------------------------------------------------------------------------------------------------------

  2306. 

  2307. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2308. {

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

  2310. 

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

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

  2313. }

  2314. 

  2315. double carla_get_sample_rate(CarlaHostHandle handle)

  2316. {

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

  2318. 

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

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

  2321. }

  2322. 

  2323. // --------------------------------------------------------------------------------------------------------------------

  2324. 

  2325. const char* carla_get_last_error(CarlaHostHandle handle)

  2326. {

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

  2328. 

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

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

  2331. 

  2332.     return handle->isStandalone

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

  2334.            : gNullCharPtr;

  2335. }

  2336. 

  2337. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2338. {

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

  2340. 

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

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

  2343.     {

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

  2345.         if (handle->isStandalone)

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

  2347.         return gNullCharPtr;

  2348.     }

  2349. 

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

  2351. 

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

  2353.         return path;

  2354. 

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

  2356.     return notAvailable;

  2357. #else

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

  2359. 

  2360.     // unused

  2361.     (void)handle;

  2362. #endif

  2363. }

  2364. 

  2365. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2366. {

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

  2368. 

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

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

  2371.     {

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

  2373.         if (handle->isStandalone)

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

  2375.         return gNullCharPtr;

  2376.     }

  2377. 

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

  2379. 

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

  2381.         return path;

  2382. 

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

  2384.     return notAvailable;

  2385. #else

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

  2387. 

  2388.     // unused

  2389.     (void)handle;

  2390. #endif

  2391. }

  2392. 

  2393. // --------------------------------------------------------------------------------------------------------------------

  2394. 

  2395. #ifndef CARLA_PLUGIN_BUILD

  2396. # define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2397. # include "CarlaPluginUI.cpp"

  2398. # undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2399. # include "CarlaDssiUtils.cpp"

  2400. # include "CarlaMacUtils.cpp"

  2401. # include "CarlaPatchbayUtils.cpp"

  2402. # include "CarlaPipeUtils.cpp"

  2403. # include "CarlaProcessUtils.cpp"

  2404. # include "CarlaStateUtils.cpp"

  2405. # include "utils/Information.cpp"

  2406. # include "utils/Windows.cpp"

  2407. #endif /* CARLA_PLUGIN_BUILD */

  2408. 

  2409. // --------------------------------------------------------------------------------------------------------------------