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

2414 lines
86KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2022 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHostImpl.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngineInit.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #if !(defined(BUILD_BRIDGE) || defined(CARLA_OS_WASM))

  32. # define CARLA_CAN_USE_LOG_THREAD

  33. # include "CarlaLogThread.hpp"

  34. #endif

  35. 

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

  37. 

  38. #ifdef USING_JUCE

  39. # include "carla_juce/carla_juce.h"

  40. #endif

  41. 

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

  43.     if (! (cond)) {                                              \

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

  45.         if (handle->isStandalone)                                \

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

  47.         return ret;                                              \

  48.     }

  49. 

  50. // -------------------------------------------------------------------------------------------------------------------

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

  52. 

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

  54. 

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

  56. {

  57.     if (charPtr == nullptr)

  58.         charPtr = gNullCharPtr;

  59. }

  60. 

  61. // -------------------------------------------------------------------------------------------------------------------

  62. // Constructors

  63. 

  64. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  65.     : type(CB::PLUGIN_NONE),

  66.       category(CB::PLUGIN_CATEGORY_NONE),

  67.       hints(0x0),

  68.       optionsAvailable(0x0),

  69.       optionsEnabled(0x0),

  70.       filename(gNullCharPtr),

  71.       name(gNullCharPtr),

  72.       label(gNullCharPtr),

  73.       maker(gNullCharPtr),

  74.       copyright(gNullCharPtr),

  75.       iconName(gNullCharPtr),

  76.       uniqueId(0) {}

  77. 

  78. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  79. {

  80.     if (label != gNullCharPtr)

  81.         delete[] label;

  82.     if (maker != gNullCharPtr)

  83.         delete[] maker;

  84.     if (copyright != gNullCharPtr)

  85.         delete[] copyright;

  86. }

  87. 

  88. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  89.     : name(gNullCharPtr),

  90.       symbol(gNullCharPtr),

  91.       unit(gNullCharPtr),

  92.       comment(gNullCharPtr),

  93.       groupName(gNullCharPtr),

  94.       scalePointCount(0) {}

  95. 

  96. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  97. {

  98.     if (name != gNullCharPtr)

  99.         delete[] name;

  100.     if (symbol != gNullCharPtr)

  101.         delete[] symbol;

  102.     if (unit != gNullCharPtr)

  103.         delete[] unit;

  104.     if (comment != gNullCharPtr)

  105.         delete[] comment;

  106.     if (groupName != gNullCharPtr)

  107.         delete[] groupName;

  108. }

  109. 

  110. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  111.     : value(0.0f),

  112.       label(gNullCharPtr) {}

  113. 

  114. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  115. {

  116.     if (label != gNullCharPtr)

  117.         delete[] label;

  118. }

  119. 

  120. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  121.     : playing(false),

  122.       frame(0),

  123.       bar(0),

  124.       beat(0),

  125.       tick(0),

  126.       bpm(0.0) {}

  127. 

  128. void _CarlaTransportInfo::clear() noexcept

  129. {

  130.     playing = false;

  131.     frame = 0;

  132.     bar = 0;

  133.     beat = 0;

  134.     tick = 0;

  135.     bpm = 0.0;

  136. }

  137. 

  138. // --------------------------------------------------------------------------------------------------------------------

  139. 

  140. using CARLA_BACKEND_NAMESPACE::CarlaPluginPtr;

  141. 

  142. // --------------------------------------------------------------------------------------------------------------------

  143. 

  144. uint carla_get_engine_driver_count()

  145. {

  146.     carla_debug("carla_get_engine_driver_count()");

  147. 

  148.     return CarlaEngine::getDriverCount();

  149. }

  150. 

  151. const char* carla_get_engine_driver_name(uint index)

  152. {

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

  154. 

  155.     return CarlaEngine::getDriverName(index);

  156. }

  157. 

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

  159. {

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

  161. 

  162.     return CarlaEngine::getDriverDeviceNames(index);

  163. }

  164. 

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

  166. {

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

  168. 

  169.     static EngineDriverDeviceInfo retDevInfo;

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

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

  172. 

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

  174. 

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

  176.     {

  177.         retDevInfo.hints       =  devInfo->hints;

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

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

  180.     }

  181.     else

  182.     {

  183.         retDevInfo.hints       = 0x0;

  184.         retDevInfo.bufferSizes = nullBufferSizes;

  185.         retDevInfo.sampleRates = nullSampleRates;

  186.     }

  187. 

  188.     return &retDevInfo;

  189. }

  190. 

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

  192. {

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

  194. }

  195. 

  196. // --------------------------------------------------------------------------------------------------------------------

  197. 

  198. CarlaHostHandle carla_standalone_host_init(void)

  199. {

  200. #ifdef CARLA_OS_UNIX

  201.     static const ThreadSafeFFTW sThreadSafeFFTW;

  202. #endif

  203. 

  204.     static CarlaHostStandalone gStandalone;

  205. 

  206.     return &gStandalone;

  207. }

  208. 

  209. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  210. {

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

  212. 

  213.     return handle->engine;

  214. }

  215. 

  216. // --------------------------------------------------------------------------------------------------------------------

  217. 

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

  219. {

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

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

  222. 

  223.     using water::File;

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

  225. 

  226. #ifdef BUILD_BRIDGE

  227.     /*

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

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

  230. 

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

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

  233. 

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

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

  236.     */

  237. 

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

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

  240. 

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

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

  243. 

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

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

  246. 

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

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

  249. 

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

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

  252. 

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

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

  255. 

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

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

  258. 

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

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

  261. 

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

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

  264. 

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

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

  267. 

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

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

  270. 

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

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

  273. 

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

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

  276. 

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

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

  279. 

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

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

  282.     else

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

  284. 

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

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

  287.     else

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

  289. 

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

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

  292. 

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

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

  295. #else

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

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

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

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

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

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

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

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

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

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

  306. 

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

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

  309. 

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

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

  312. 

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

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

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

  316. 

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

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

  319. 

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

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

  322. 

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

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

  325. 

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

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

  328. 

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

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

  331. 

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

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

  334. 

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

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

  337. 

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

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

  340. 

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

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

  343. 

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

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

  346. 

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

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

  349.     else

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

  351. 

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

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

  354. 

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

  356. 

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

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

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

  360. 

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

  362.     {

  363.         char strBuf[STR_MAX+1];

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

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

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

  367.     }

  368.     else

  369.     {

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

  371.     }

  372. 

  373. # ifndef CARLA_OS_WIN

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

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

  376. 

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

  378. 

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

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

  381. 

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

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

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

  385. # endif

  386. 

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

  388. 

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

  390. #endif // BUILD_BRIDGE

  391. }

  392. 

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

  394. {

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

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

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

  398. 

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

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

  401. 

  402. #ifdef CARLA_OS_WIN

  403.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  404. #endif

  405. 

  406. #ifdef USING_JUCE

  407.     CarlaJUCE::initialiseJuce_GUI();

  408. #endif

  409. 

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

  411. 

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

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

  414. 

  415.     shandle.engine = engine;

  416. 

  417. #ifdef BUILD_BRIDGE

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

  419.     {

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

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

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

  423. 

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

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

  426.     }

  427.     else

  428.     {

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

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

  431.     }

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

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

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

  435. #else

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

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

  438. #endif

  439. 

  440.     carla_engine_init_common(shandle, engine);

  441. 

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

  443.     {

  444. #ifdef CARLA_CAN_USE_LOG_THREAD

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

  446.             shandle.logThread.init();

  447. #endif

  448.         shandle.lastError = "No error";

  449.         return true;

  450.     }

  451.     else

  452.     {

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

  454.         shandle.engine = nullptr;

  455.         delete engine;

  456. #ifdef USING_JUCE

  457.         CarlaJUCE::shutdownJuce_GUI();

  458. #endif

  459.         return false;

  460.     }

  461. }

  462. 

  463. #ifdef BUILD_BRIDGE

  464. bool carla_engine_init_bridge(CarlaHostHandle handle,

  465.                               const char audioBaseName[6+1],

  466.                               const char rtClientBaseName[6+1],

  467.                               const char nonRtClientBaseName[6+1],

  468.                               const char nonRtServerBaseName[6+1],

  469.                               const char* const clientName)

  470. {

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

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

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

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

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

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

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

  478. 

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

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

  481. 

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

  483.                                                                      rtClientBaseName,

  484.                                                                      nonRtClientBaseName,

  485.                                                                      nonRtServerBaseName));

  486. 

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

  488. 

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

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

  491. 

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

  493. 

  494.     carla_engine_init_common(shandle, engine);

  495. 

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

  497.     {

  498.         shandle.lastError = "No error";

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

  500.         return true;

  501.     }

  502.     else

  503.     {

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

  505.         return false;

  506.     }

  507. }

  508. #endif

  509. 

  510. bool carla_engine_close(CarlaHostHandle handle)

  511. {

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

  513. 

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

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

  516. 

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

  518. 

  519.     CarlaEngine* const engine = shandle.engine;

  520. 

  521.     engine->setAboutToClose();

  522.     engine->removeAllPlugins();

  523. 

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

  525. 

  526.     if (! closed)

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

  528. 

  529. #ifdef CARLA_CAN_USE_LOG_THREAD

  530.     shandle.logThread.stop();

  531. #endif

  532. 

  533.     shandle.engine = nullptr;

  534.     delete engine;

  535. 

  536. #ifdef USING_JUCE

  537.     CarlaJUCE::shutdownJuce_GUI();

  538. #endif

  539.     return closed;

  540. }

  541. 

  542. void carla_engine_idle(CarlaHostHandle handle)

  543. {

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

  545. 

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

  547. 

  548. #ifdef USING_JUCE

  549.     if (handle->isStandalone)

  550.         CarlaJUCE::idleJuce_GUI();

  551. #endif

  552. }

  553. 

  554. bool carla_is_engine_running(CarlaHostHandle handle)

  555. {

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

  557. }

  558. 

  559. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  560. {

  561.     static CarlaRuntimeEngineInfo retInfo;

  562. 

  563.     // reset

  564.     retInfo.load = 0.0f;

  565.     retInfo.xruns = 0;

  566. 

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

  568. 

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

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

  571. 

  572.     return &retInfo;

  573. }

  574. 

  575. #ifndef BUILD_BRIDGE

  576. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  577. {

  578.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  579. 

  580.     // reset

  581.     retInfo.name = gNullCharPtr;

  582.     retInfo.hints = 0x0;

  583.     retInfo.bufferSize = 0;

  584.     retInfo.bufferSizes = nullptr;

  585.     retInfo.sampleRate = 0.0;

  586.     retInfo.sampleRates = nullptr;

  587. 

  588.     const char* audioDriver;

  589.     const char* audioDevice;

  590. 

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

  592.     {

  593.         audioDriver = engine->getCurrentDriverName();

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

  595. 

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

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

  598.     }

  599.     else if (handle->isStandalone)

  600.     {

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

  602. 

  603.         audioDriver = shandle.engineOptions.audioDriver;

  604.         audioDevice = shandle.engineOptions.audioDevice;

  605. 

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

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

  608.     }

  609.     else

  610.     {

  611.         return &retInfo;

  612.     }

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

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

  615. 

  616.     uint index = 0;

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

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

  619.     {

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

  621.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  622. 

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

  624.             break;

  625.     }

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

  627. 

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

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

  630. 

  631.     retInfo.name        = audioDevice;

  632.     retInfo.hints       = devInfo->hints;

  633.     retInfo.bufferSizes = devInfo->bufferSizes;

  634.     retInfo.sampleRates = devInfo->sampleRates;

  635. 

  636.     return &retInfo;

  637. }

  638. 

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

  640. {

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

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

  643. 

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

  645. }

  646. 

  647. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  648. {

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

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

  651. 

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

  653. }

  654. #endif // BUILD_BRIDGE

  655. 

  656. void carla_clear_engine_xruns(CarlaHostHandle handle)

  657. {

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

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

  660. }

  661. 

  662. void carla_cancel_engine_action(CarlaHostHandle handle)

  663. {

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

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

  666. }

  667. 

  668. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  669. {

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

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

  672. 

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

  674. }

  675. 

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

  677. {

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

  679. 

  680.     if (handle->isStandalone)

  681.     {

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

  683. 

  684.         shandle.engineCallback    = func;

  685.         shandle.engineCallbackPtr = ptr;

  686. 

  687. #ifdef CARLA_CAN_USE_LOG_THREAD

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

  689. #endif

  690.     }

  691. 

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

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

  694. }

  695. 

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

  697. {

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

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

  700. 

  701.     if (handle->isStandalone)

  702.     {

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

  704. 

  705.         switch (option)

  706.         {

  707.         case CB::ENGINE_OPTION_DEBUG:

  708.             break;

  709. 

  710.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  713.             break;

  714. 

  715.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  717. 

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

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

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

  721.             {

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

  723. 

  724.                 if (shandle.engineCallback != nullptr)

  725.                     shandle.engineCallback(shandle.engineCallbackPtr,

  726.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  727.                                            0,

  728.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  729.                                            0, 0, 0.0f,

  730.                                            shandle.engineOptions.transportExtra);

  731.             }

  732.             else

  733.             {

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

  735.             }

  736. 

  737.             delete[] shandle.engineOptions.transportExtra;

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

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

  740.             else

  741.                 shandle.engineOptions.transportExtra = nullptr;

  742.             break;

  743. 

  744.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  747.             break;

  748. 

  749.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  752.             break;

  753. 

  754.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  757.             break;

  758. 

  759.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  762.             break;

  763. 

  764.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  765.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  767.             break;

  768. 

  769.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  772.             break;

  773. 

  774.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  775.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  777.             break;

  778. 

  779.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  780.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  782.             break;

  783. 

  784.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  785.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  787.             break;

  788. 

  789.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  792.             break;

  793. 

  794.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  795.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  796. 

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

  798.                 delete[] shandle.engineOptions.audioDriver;

  799. 

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

  801.             break;

  802. 

  803.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  804.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  805. 

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

  807.                 delete[] shandle.engineOptions.audioDevice;

  808. 

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

  810.             break;

  811. 

  812. #ifndef BUILD_BRIDGE

  813.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  816.             break;

  817. 

  818.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  820.             shandle.engineOptions.oscPortTCP = value;

  821.             break;

  822. 

  823.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  825.             shandle.engineOptions.oscPortUDP = value;

  826.             break;

  827. #endif

  828. 

  829.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  832.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  833. 

  834.             switch (value)

  835.             {

  836.             case CB::FILE_AUDIO:

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

  838.                     delete[] shandle.engineOptions.pathAudio;

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

  840.                 break;

  841.             case CB::FILE_MIDI:

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

  843.                     delete[] shandle.engineOptions.pathMIDI;

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

  845.                 break;

  846.             }

  847.             break;

  848. 

  849.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  852.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  853. 

  854.             switch (value)

  855.             {

  856.             case CB::PLUGIN_LADSPA:

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

  858.                     delete[] shandle.engineOptions.pathLADSPA;

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

  860.                 break;

  861.             case CB::PLUGIN_DSSI:

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

  863.                     delete[] shandle.engineOptions.pathDSSI;

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

  865.                 break;

  866.             case CB::PLUGIN_LV2:

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

  868.                     delete[] shandle.engineOptions.pathLV2;

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

  870.                 break;

  871.             case CB::PLUGIN_VST2:

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

  873.                     delete[] shandle.engineOptions.pathVST2;

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

  875.                 break;

  876.             case CB::PLUGIN_VST3:

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

  878.                     delete[] shandle.engineOptions.pathVST3;

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

  880.                 break;

  881.             case CB::PLUGIN_SF2:

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

  883.                     delete[] shandle.engineOptions.pathSF2;

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

  885.                 break;

  886.             case CB::PLUGIN_SFZ:

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

  888.                     delete[] shandle.engineOptions.pathSFZ;

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

  890.                 break;

  891.             case CB::PLUGIN_JSFX:

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

  893.                     delete[] shandle.engineOptions.pathJSFX;

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

  895.                 break;

  896.             }

  897.             break;

  898. 

  899.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  901. 

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

  903.                 delete[] shandle.engineOptions.binaryDir;

  904. 

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

  906.             break;

  907. 

  908.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  910. 

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

  912.                 delete[] shandle.engineOptions.resourceDir;

  913. 

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

  915.             break;

  916. 

  917.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  920.             break;

  921. 

  922.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  924.             break;

  925. 

  926.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  928.             break;

  929. 

  930.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  931.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  933.             break;

  934. 

  935.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  938.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  940.         }   break;

  941. 

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

  943.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  945. 

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

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

  948. 

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

  950.             break;

  951. 

  952.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  955.             break;

  956. 

  957.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  959. 

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

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

  962. 

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

  964.             break;

  965. 

  966.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  969.             break;

  970. 

  971.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  974.             break;

  975. 

  976.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  979.             break;

  980. #endif

  981. 

  982. #ifndef BUILD_BRIDGE

  983.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  984. #ifdef CARLA_CAN_USE_LOG_THREAD

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

  986. #endif

  987.             break;

  988. #endif

  989. 

  990.         case CB::ENGINE_OPTION_CLIENT_NAME_PREFIX:

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

  992.                 delete[] shandle.engineOptions.clientNamePrefix;

  993. 

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

  995.                                                    ? carla_strdup_safe(valueStr)

  996.                                                    : nullptr;

  997.             break;

  998. 

  999.         case CB::ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

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

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

  1002.             break;

  1003.         }

  1004.     }

  1005. 

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

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

  1008. }

  1009. 

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

  1011. {

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

  1013. 

  1014.     if (handle->isStandalone)

  1015.     {

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

  1017. 

  1018.         shandle.fileCallback    = func;

  1019.         shandle.fileCallbackPtr = ptr;

  1020.     }

  1021. 

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

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

  1024. }

  1025. 

  1026. // --------------------------------------------------------------------------------------------------------------------

  1027. 

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

  1029. {

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

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

  1032. 

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

  1034. 

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

  1036. }

  1037. 

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

  1039. {

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

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

  1042. 

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

  1044. 

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

  1046. }

  1047. 

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

  1049. {

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

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

  1052. 

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

  1054. 

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

  1056. }

  1057. 

  1058. #ifndef BUILD_BRIDGE

  1059. const char* carla_get_current_project_folder(CarlaHostHandle handle)

  1060. {

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

  1062. 

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

  1064. 

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

  1066.         return ret;

  1067. 

  1068.     return gNullCharPtr;

  1069. }

  1070. 

  1071. const char* carla_get_current_project_filename(CarlaHostHandle handle)

  1072. {

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

  1074. 

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

  1076. 

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

  1078.         return ret;

  1079. 

  1080.     return gNullCharPtr;

  1081. }

  1082. 

  1083. void carla_clear_project_filename(CarlaHostHandle handle)

  1084. {

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

  1086. 

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

  1088. 

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

  1090. }

  1091. 

  1092. // --------------------------------------------------------------------------------------------------------------------

  1093. 

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

  1095. {

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

  1097. 

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

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

  1100. 

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

  1102. }

  1103. 

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

  1105. {

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

  1107. 

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

  1109. 

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

  1111. }

  1112. 

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

  1114. {

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

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

  1117. 

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

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

  1120. 

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

  1122.         return true;

  1123. 

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

  1125. }

  1126. 

  1127. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  1128. {

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

  1130. 

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

  1132. 

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

  1134. }

  1135. 

  1136. // --------------------------------------------------------------------------------------------------------------------

  1137. 

  1138. void carla_transport_play(CarlaHostHandle handle)

  1139. {

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

  1141. 

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

  1143. 

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

  1145. }

  1146. 

  1147. void carla_transport_pause(CarlaHostHandle handle)

  1148. {

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

  1150. 

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

  1152. 

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

  1154. }

  1155. 

  1156. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1157. {

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

  1159. 

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

  1161. 

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

  1163. }

  1164. 

  1165. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1166. {

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

  1168. 

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

  1170. 

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

  1172. }

  1173. 

  1174. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1175. {

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

  1177. 

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

  1179. }

  1180. 

  1181. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1182. {

  1183.     static CarlaTransportInfo retTransInfo;

  1184.     retTransInfo.clear();

  1185. 

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

  1187. 

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

  1189. 

  1190.     retTransInfo.playing = timeInfo.playing;

  1191.     retTransInfo.frame   = timeInfo.frame;

  1192. 

  1193.     if (timeInfo.bbt.valid)

  1194.     {

  1195.         retTransInfo.bar  = timeInfo.bbt.bar;

  1196.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1199.     }

  1200. 

  1201.     return &retTransInfo;

  1202. }

  1203. #endif

  1204. 

  1205. // --------------------------------------------------------------------------------------------------------------------

  1206. 

  1207. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1208. {

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

  1210. 

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

  1212. 

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

  1214. }

  1215. 

  1216. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1217. {

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

  1219. 

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

  1221. 

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

  1223. }

  1224. 

  1225. // --------------------------------------------------------------------------------------------------------------------

  1226. 

  1227. bool carla_add_plugin(CarlaHostHandle handle,

  1228.                       BinaryType btype, PluginType ptype,

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

  1230.                       const void* extraPtr, uint options)

  1231. {

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

  1233. 

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

  1235.                 handle,

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

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

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

  1239. 

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

  1241. }

  1242. 

  1243. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1244. {

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

  1246. 

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

  1248. 

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

  1250. }

  1251. 

  1252. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1253. {

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

  1255. 

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

  1257. 

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

  1259. }

  1260. 

  1261. #ifndef BUILD_BRIDGE

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

  1263. {

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

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

  1266. 

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

  1268. 

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

  1270. }

  1271. 

  1272. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1273. {

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

  1275. 

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

  1277. 

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

  1279. }

  1280. 

  1281. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1282. {

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

  1284. 

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

  1286. 

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

  1288. }

  1289. 

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

  1291. {

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

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

  1294. 

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

  1296. 

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

  1298. }

  1299. #endif

  1300. 

  1301. // --------------------------------------------------------------------------------------------------------------------

  1302. 

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

  1304. {

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

  1306.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1308. 

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

  1310.         return plugin->loadStateFromFile(filename);

  1311. 

  1312.     return false;

  1313. }

  1314. 

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

  1316. {

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

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

  1319. 

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

  1321.         return plugin->saveStateToFile(filename);

  1322. 

  1323.     return false;

  1324. }

  1325. 

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

  1327. {

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

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

  1330. 

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

  1332.         return plugin->exportAsLV2(lv2path);

  1333. 

  1334.     return false;

  1335. }

  1336. 

  1337. // --------------------------------------------------------------------------------------------------------------------

  1338. 

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

  1340. {

  1341.     static CarlaPluginInfo retInfo;

  1342. 

  1343.     // reset

  1344.     retInfo.type             = CB::PLUGIN_NONE;

  1345.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1346.     retInfo.hints            = 0x0;

  1347.     retInfo.optionsAvailable = 0x0;

  1348.     retInfo.optionsEnabled   = 0x0;

  1349.     retInfo.filename         = gNullCharPtr;

  1350.     retInfo.name             = gNullCharPtr;

  1351.     retInfo.iconName         = gNullCharPtr;

  1352.     retInfo.uniqueId         = 0;

  1353. 

  1354.     // cleanup

  1355.     if (retInfo.label != gNullCharPtr)

  1356.     {

  1357.         delete[] retInfo.label;

  1358.         retInfo.label = gNullCharPtr;

  1359.     }

  1360. 

  1361.     if (retInfo.maker != gNullCharPtr)

  1362.     {

  1363.         delete[] retInfo.maker;

  1364.         retInfo.maker = gNullCharPtr;

  1365.     }

  1366. 

  1367.     if (retInfo.copyright != gNullCharPtr)

  1368.     {

  1369.         delete[] retInfo.copyright;

  1370.         retInfo.copyright = gNullCharPtr;

  1371.     }

  1372. 

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

  1374. 

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

  1376.     {

  1377.         char strBuf[STR_MAX+1];

  1378.         carla_zeroChars(strBuf, STR_MAX+1);

  1379. 

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

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

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

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

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

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

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

  1387. 

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

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

  1390. 

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

  1392.             retInfo.label = carla_strdup_safe(strBuf);

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

  1394.             retInfo.maker = carla_strdup_safe(strBuf);

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

  1396.             retInfo.copyright = carla_strdup_safe(strBuf);

  1397. 

  1398.         checkStringPtr(retInfo.filename);

  1399.         checkStringPtr(retInfo.name);

  1400.         checkStringPtr(retInfo.iconName);

  1401.         checkStringPtr(retInfo.label);

  1402.         checkStringPtr(retInfo.maker);

  1403.         checkStringPtr(retInfo.copyright);

  1404.     }

  1405. 

  1406.     return &retInfo;

  1407. }

  1408. 

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

  1410. {

  1411.     static CarlaPortCountInfo retInfo;

  1412.     carla_zeroStruct(retInfo);

  1413. 

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

  1415. 

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

  1417.     {

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

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

  1420.     }

  1421. 

  1422.     return &retInfo;

  1423. }

  1424. 

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

  1426. {

  1427.     static CarlaPortCountInfo retInfo;

  1428.     carla_zeroStruct(retInfo);

  1429. 

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

  1431. 

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

  1433.     {

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

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

  1436.     }

  1437. 

  1438.     return &retInfo;

  1439. }

  1440. 

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

  1442. {

  1443.     static CarlaPortCountInfo retInfo;

  1444.     carla_zeroStruct(retInfo);

  1445. 

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

  1447. 

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

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

  1450. 

  1451.     return &retInfo;

  1452. }

  1453. 

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

  1455. {

  1456.     static CarlaParameterInfo retInfo;

  1457. 

  1458.     // reset

  1459.     retInfo.scalePointCount = 0;

  1460. 

  1461.     // cleanup

  1462.     if (retInfo.name != gNullCharPtr)

  1463.     {

  1464.         delete[] retInfo.name;

  1465.         retInfo.name = gNullCharPtr;

  1466.     }

  1467. 

  1468.     if (retInfo.symbol != gNullCharPtr)

  1469.     {

  1470.         delete[] retInfo.symbol;

  1471.         retInfo.symbol = gNullCharPtr;

  1472.     }

  1473. 

  1474.     if (retInfo.unit != gNullCharPtr)

  1475.     {

  1476.         delete[] retInfo.unit;

  1477.         retInfo.unit = gNullCharPtr;

  1478.     }

  1479. 

  1480.     if (retInfo.comment != gNullCharPtr)

  1481.     {

  1482.         delete[] retInfo.comment;

  1483.         retInfo.comment = gNullCharPtr;

  1484.     }

  1485. 

  1486.     if (retInfo.groupName != gNullCharPtr)

  1487.     {

  1488.         delete[] retInfo.groupName;

  1489.         retInfo.groupName = gNullCharPtr;

  1490.     }

  1491. 

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

  1493. 

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

  1495.     {

  1496.         char strBuf[STR_MAX+1];

  1497.         carla_zeroChars(strBuf, STR_MAX+1);

  1498. 

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

  1500. 

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

  1502.         {

  1503.             retInfo.name = carla_strdup_safe(strBuf);

  1504.             carla_zeroChars(strBuf, STR_MAX+1);

  1505.         }

  1506. 

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

  1508.         {

  1509.             retInfo.symbol = carla_strdup_safe(strBuf);

  1510.             carla_zeroChars(strBuf, STR_MAX+1);

  1511.         }

  1512. 

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

  1514.         {

  1515.             retInfo.unit = carla_strdup_safe(strBuf);

  1516.             carla_zeroChars(strBuf, STR_MAX+1);

  1517.         }

  1518. 

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

  1520.         {

  1521.             retInfo.comment = carla_strdup_safe(strBuf);

  1522.             carla_zeroChars(strBuf, STR_MAX+1);

  1523.         }

  1524. 

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

  1526.         {

  1527.             retInfo.groupName = carla_strdup_safe(strBuf);

  1528.             carla_zeroChars(strBuf, STR_MAX+1);

  1529.         }

  1530. 

  1531.         checkStringPtr(retInfo.name);

  1532.         checkStringPtr(retInfo.symbol);

  1533.         checkStringPtr(retInfo.unit);

  1534.         checkStringPtr(retInfo.comment);

  1535.         checkStringPtr(retInfo.groupName);

  1536.     }

  1537. 

  1538.     return &retInfo;

  1539. }

  1540. 

  1541. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1542.                                                                uint pluginId,

  1543.                                                                uint32_t parameterId,

  1544.                                                                uint32_t scalePointId)

  1545. {

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

  1547. 

  1548.     static CarlaScalePointInfo retInfo;

  1549. 

  1550.     // reset

  1551.     retInfo.value = 0.0f;

  1552. 

  1553.     // cleanup

  1554.     if (retInfo.label != gNullCharPtr)

  1555.     {

  1556.         delete[] retInfo.label;

  1557.         retInfo.label = gNullCharPtr;

  1558.     }

  1559. 

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

  1561. 

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

  1563.     {

  1564.         char strBuf[STR_MAX+1];

  1565. 

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

  1567. 

  1568.         carla_zeroChars(strBuf, STR_MAX+1);

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

  1570.             retInfo.label = carla_strdup_safe(strBuf);

  1571. 

  1572.         checkStringPtr(retInfo.label);

  1573.     }

  1574. 

  1575.     return &retInfo;

  1576. }

  1577. 

  1578. // --------------------------------------------------------------------------------------------------------------------

  1579. 

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

  1581. {

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

  1583. 

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

  1585.     {

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

  1587. 

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

  1589.     }

  1590. 

  1591.     return 0x0;

  1592. }

  1593. 

  1594. // --------------------------------------------------------------------------------------------------------------------

  1595. 

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

  1597. {

  1598.     static ParameterData retParamData;

  1599. 

  1600.     // reset

  1601.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1602.     retParamData.hints       = 0x0;

  1603.     retParamData.index       = CB::PARAMETER_NULL;

  1604.     retParamData.rindex      = -1;

  1605.     retParamData.midiChannel = 0;

  1606.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1607.     retParamData.mappedMinimum = 0.0f;

  1608.     retParamData.mappedMaximum = 0.0f;

  1609. 

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

  1611. 

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

  1613.     {

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

  1615. 

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

  1617.         retParamData.type        = pluginParamData.type;

  1618.         retParamData.hints       = pluginParamData.hints;

  1619.         retParamData.index       = pluginParamData.index;

  1620.         retParamData.rindex      = pluginParamData.rindex;

  1621.         retParamData.midiChannel = pluginParamData.midiChannel;

  1622.         retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1623.         retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1624.         retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1625.     }

  1626. 

  1627.     return &retParamData;

  1628. }

  1629. 

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

  1631. {

  1632.     static ParameterRanges retParamRanges;

  1633. 

  1634.     // reset

  1635.     retParamRanges.def       = 0.0f;

  1636.     retParamRanges.min       = 0.0f;

  1637.     retParamRanges.max       = 1.0f;

  1638.     retParamRanges.step      = 0.01f;

  1639.     retParamRanges.stepSmall = 0.0001f;

  1640.     retParamRanges.stepLarge = 0.1f;

  1641. 

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

  1643. 

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

  1645.     {

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

  1647. 

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

  1649.         retParamRanges.def       = pluginParamRanges.def;

  1650.         retParamRanges.min       = pluginParamRanges.min;

  1651.         retParamRanges.max       = pluginParamRanges.max;

  1652.         retParamRanges.step      = pluginParamRanges.step;

  1653.         retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1654.         retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1655.     }

  1656. 

  1657.     return &retParamRanges;

  1658. }

  1659. 

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

  1661. {

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

  1663. 

  1664.     // reset

  1665.     retMidiProgData.bank    = 0;

  1666.     retMidiProgData.program = 0;

  1667. 

  1668.     if (retMidiProgData.name != gNullCharPtr)

  1669.     {

  1670.         delete[] retMidiProgData.name;

  1671.         retMidiProgData.name = gNullCharPtr;

  1672.     }

  1673. 

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

  1675. 

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

  1677.     {

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

  1679. 

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

  1681.         retMidiProgData.bank    = pluginMidiProgData.bank;

  1682.         retMidiProgData.program = pluginMidiProgData.program;

  1683. 

  1684.         if (pluginMidiProgData.name != nullptr)

  1685.         {

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

  1687.             checkStringPtr(retMidiProgData.name);

  1688.         }

  1689.         else

  1690.         {

  1691.             retMidiProgData.name = gNullCharPtr;

  1692.         }

  1693.     }

  1694. 

  1695.     return &retMidiProgData;

  1696. }

  1697. 

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

  1699. {

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

  1701. 

  1702.     // reset

  1703.     if (retCustomData.type != gNullCharPtr)

  1704.     {

  1705.         delete[] retCustomData.type;

  1706.         retCustomData.type = gNullCharPtr;

  1707.     }

  1708. 

  1709.     if (retCustomData.key != gNullCharPtr)

  1710.     {

  1711.         delete[] retCustomData.key;

  1712.         retCustomData.key = gNullCharPtr;

  1713.     }

  1714. 

  1715.     if (retCustomData.value != gNullCharPtr)

  1716.     {

  1717.         delete[] retCustomData.value;

  1718.         retCustomData.value = gNullCharPtr;

  1719.     }

  1720. 

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

  1722. 

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

  1724.     {

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

  1726. 

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

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

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

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

  1731.         checkStringPtr(retCustomData.type);

  1732.         checkStringPtr(retCustomData.key);

  1733.         checkStringPtr(retCustomData.value);

  1734.     }

  1735. 

  1736.     return &retCustomData;

  1737. }

  1738. 

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

  1740. {

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

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

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

  1744. 

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

  1746.     {

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

  1748. 

  1749.         if (count == 0)

  1750.             return gNullCharPtr;

  1751. 

  1752.         static CarlaString customDataValue;

  1753. 

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

  1755.         {

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

  1757. 

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

  1759.                 continue;

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

  1761.                 continue;

  1762. 

  1763.             customDataValue = pluginCustomData.value;

  1764.             return customDataValue.buffer();

  1765.         }

  1766.     }

  1767. 

  1768.     return gNullCharPtr;

  1769. }

  1770. 

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

  1772. {

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

  1774. 

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

  1776.     {

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

  1778. 

  1779.         void* data = nullptr;

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

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

  1782. 

  1783.         static CarlaString chunkData;

  1784. 

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

  1786.         return chunkData.buffer();

  1787.     }

  1788. 

  1789.     return gNullCharPtr;

  1790. }

  1791. 

  1792. // --------------------------------------------------------------------------------------------------------------------

  1793. 

  1794. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1795. {

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

  1797. 

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

  1799.         return plugin->getParameterCount();

  1800. 

  1801.     return 0;

  1802. }

  1803. 

  1804. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1805. {

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

  1807. 

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

  1809.         return plugin->getProgramCount();

  1810. 

  1811.     return 0;

  1812. }

  1813. 

  1814. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1815. {

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

  1817. 

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

  1819.         return plugin->getMidiProgramCount();

  1820. 

  1821.     return 0;

  1822. }

  1823. 

  1824. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1825. {

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

  1827. 

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

  1829.         return plugin->getCustomDataCount();

  1830. 

  1831.     return 0;

  1832. }

  1833. 

  1834. // --------------------------------------------------------------------------------------------------------------------

  1835. 

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

  1837. {

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

  1839. 

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

  1841.     {

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

  1843. 

  1844.         static char textBuf[STR_MAX+1];

  1845.         carla_zeroChars(textBuf, STR_MAX+1);

  1846. 

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

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

  1849. 

  1850.         return textBuf;

  1851.     }

  1852. 

  1853.     return gNullCharPtr;

  1854. }

  1855. 

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

  1857. {

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

  1859. 

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

  1861.     {

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

  1863. 

  1864.         static char programName[STR_MAX+1];

  1865.         carla_zeroChars(programName, STR_MAX+1);

  1866. 

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

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

  1869. 

  1870.         return programName;

  1871.     }

  1872. 

  1873.     return gNullCharPtr;

  1874. }

  1875. 

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

  1877. {

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

  1879. 

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

  1881.     {

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

  1883. 

  1884.         static char midiProgramName[STR_MAX+1];

  1885.         carla_zeroChars(midiProgramName, STR_MAX+1);

  1886. 

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

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

  1889. 

  1890.         return midiProgramName;

  1891.     }

  1892. 

  1893.     return gNullCharPtr;

  1894. }

  1895. 

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

  1897. {

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

  1899. 

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

  1901.     {

  1902.         static char realPluginName[STR_MAX+1];

  1903.         carla_zeroChars(realPluginName, STR_MAX+1);

  1904. 

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

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

  1907. 

  1908.         return realPluginName;

  1909.     }

  1910. 

  1911.     return gNullCharPtr;

  1912. }

  1913. 

  1914. // --------------------------------------------------------------------------------------------------------------------

  1915. 

  1916. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1917. {

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

  1919. 

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

  1921.         return plugin->getCurrentProgram();

  1922. 

  1923.     return -1;

  1924. }

  1925. 

  1926. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1927. {

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

  1929. 

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

  1931.         return plugin->getCurrentMidiProgram();

  1932. 

  1933.     return -1;

  1934. }

  1935. 

  1936. // --------------------------------------------------------------------------------------------------------------------

  1937. 

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

  1939. {

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

  1941. 

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

  1943.     {

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

  1945. 

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

  1947.     }

  1948. 

  1949.     return 0.0f;

  1950. }

  1951. 

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

  1953. {

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

  1955. 

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

  1957.     {

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

  1959. 

  1960.         return plugin->getParameterValue(parameterId);

  1961.     }

  1962. 

  1963.     return 0.0f;

  1964. }

  1965. 

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

  1967. {

  1968. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1970. #else

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

  1972. #endif

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

  1974. 

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

  1976.         return plugin->getInternalParameterValue(parameterId);

  1977. 

  1978.     return 0.0f;

  1979. }

  1980. 

  1981. // --------------------------------------------------------------------------------------------------------------------

  1982. 

  1983. uint32_t carla_get_plugin_latency(CarlaHostHandle handle, uint pluginId)

  1984. {

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

  1986. 

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

  1988.          return plugin->getLatencyInFrames();

  1989. 

  1990.     return 0;

  1991. }

  1992. 

  1993. // --------------------------------------------------------------------------------------------------------------------

  1994. 

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

  1996. {

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

  1998. 

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

  2000. }

  2001. 

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

  2003. {

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

  2005. 

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

  2007. }

  2008. 

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

  2010. {

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

  2012. 

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

  2014. }

  2015. 

  2016. // --------------------------------------------------------------------------------------------------------------------

  2017. 

  2018. CARLA_BACKEND_START_NAMESPACE

  2019. 

  2020. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2021. // defined in CarlaPluginInternal.cpp

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

  2023. #endif

  2024. 

  2025. // defined in CarlaPluginLV2.cpp

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

  2027. 

  2028. CARLA_BACKEND_END_NAMESPACE

  2029. 

  2030. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  2031.                                                                   uint pluginId,

  2032.                                                                   uint32_t width, uint32_t height)

  2033. {

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

  2035. 

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

  2037.         return nullptr;

  2038. 

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

  2040.     {

  2041.         switch (plugin->getType())

  2042.         {

  2043. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2044.         case CB::PLUGIN_INTERNAL:

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

  2046. #endif

  2047.         case CB::PLUGIN_LV2:

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

  2049.         default:

  2050.             return nullptr;

  2051.         }

  2052.     }

  2053. 

  2054.     return nullptr;

  2055. }

  2056. 

  2057. // --------------------------------------------------------------------------------------------------------------------

  2058. 

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

  2060. {

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

  2062. 

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

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

  2065. }

  2066. 

  2067. #ifndef BUILD_BRIDGE

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

  2069. {

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

  2071. 

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

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

  2074. }

  2075. 

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

  2077. {

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

  2079. 

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

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

  2082. }

  2083. 

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

  2085. {

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

  2087. 

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

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

  2090. }

  2091. 

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

  2093. {

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

  2095. 

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

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

  2098. }

  2099. 

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

  2101. {

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

  2103. 

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

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

  2106. }

  2107. 

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

  2109. {

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

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

  2112. 

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

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

  2115. }

  2116. #endif

  2117. 

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

  2119. {

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

  2121. 

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

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

  2124. }

  2125. 

  2126. // --------------------------------------------------------------------------------------------------------------------

  2127. 

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

  2129. {

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

  2131. 

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

  2133.     {

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

  2135. 

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

  2137.     }

  2138. }

  2139. 

  2140. #ifndef BUILD_BRIDGE

  2141. 

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

  2143. {

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

  2145.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2146. 

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

  2148.     {

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

  2150. 

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

  2152.     }

  2153. }

  2154. 

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

  2156. {

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

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

  2159. 

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

  2161.     {

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

  2163. 

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

  2165.     }

  2166. }

  2167. 

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

  2169. {

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

  2171. 

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

  2173.     {

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

  2175. 

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

  2177.     }

  2178. }

  2179. 

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

  2181. {

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

  2183. 

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

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

  2186. }

  2187. #endif

  2188. 

  2189. // --------------------------------------------------------------------------------------------------------------------

  2190. 

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

  2192. {

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

  2194. 

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

  2196.     {

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

  2198. 

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

  2200.     }

  2201. }

  2202. 

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

  2204. {

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

  2206. 

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

  2208.     {

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

  2210. 

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

  2212.     }

  2213. }

  2214. 

  2215. // --------------------------------------------------------------------------------------------------------------------

  2216. 

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

  2218. {

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

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

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

  2222.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2223. 

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

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

  2226. }

  2227. 

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

  2229. {

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

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

  2232. 

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

  2234.     {

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

  2236. 

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

  2238. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2240. #else

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

  2242. #endif

  2243.     }

  2244. }

  2245. 

  2246. // --------------------------------------------------------------------------------------------------------------------

  2247. 

  2248. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2249. {

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

  2251. 

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

  2253.         plugin->prepareForSave(false);

  2254. }

  2255. 

  2256. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2257. {

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

  2259. 

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

  2261.         plugin->resetParameters();

  2262. }

  2263. 

  2264. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2265. {

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

  2267. 

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

  2269.         plugin->randomizeParameters();

  2270. }

  2271. 

  2272. #ifndef BUILD_BRIDGE

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

  2274. {

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

  2276. 

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

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

  2279. }

  2280. #endif

  2281. 

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

  2283. {

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

  2285.     CARLA_SAFE_ASSERT_RETURN(title != nullptr,);

  2286. 

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

  2288.         plugin->setCustomUITitle(title);

  2289. }

  2290. 

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

  2292. {

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

  2294. 

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

  2296.         plugin->showCustomUI(yesNo);

  2297. }

  2298. 

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

  2300. {

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

  2302. 

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

  2304.         return plugin->embedCustomUI(ptr);

  2305. 

  2306.     return nullptr;

  2307. }

  2308. 

  2309. // --------------------------------------------------------------------------------------------------------------------

  2310. 

  2311. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2312. {

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

  2314. 

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

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

  2317. }

  2318. 

  2319. double carla_get_sample_rate(CarlaHostHandle handle)

  2320. {

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

  2322. 

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

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

  2325. }

  2326. 

  2327. // --------------------------------------------------------------------------------------------------------------------

  2328. 

  2329. const char* carla_get_last_error(CarlaHostHandle handle)

  2330. {

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

  2332. 

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

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

  2335. 

  2336.     return handle->isStandalone

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

  2338.            : gNullCharPtr;

  2339. }

  2340. 

  2341. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2342. {

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

  2344. 

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

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

  2347.     {

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

  2349.         if (handle->isStandalone)

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

  2351.         return gNullCharPtr;

  2352.     }

  2353. 

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

  2355. 

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

  2357.         return path;

  2358. 

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

  2360.     return notAvailable;

  2361. #else

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

  2363. 

  2364.     // unused

  2365.     (void)handle;

  2366. #endif

  2367. }

  2368. 

  2369. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2370. {

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

  2372. 

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

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

  2375.     {

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

  2377.         if (handle->isStandalone)

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

  2379.         return gNullCharPtr;

  2380.     }

  2381. 

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

  2383. 

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

  2385.         return path;

  2386. 

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

  2388.     return notAvailable;

  2389. #else

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

  2391. 

  2392.     // unused

  2393.     (void)handle;

  2394. #endif

  2395. }

  2396. 

  2397. // --------------------------------------------------------------------------------------------------------------------

  2398. 

  2399. #ifndef CARLA_PLUGIN_BUILD

  2400. # define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2401. # include "CarlaPluginUI.cpp"

  2402. # undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2403. # include "CarlaDssiUtils.cpp"

  2404. # include "CarlaMacUtils.cpp"

  2405. # include "CarlaPatchbayUtils.cpp"

  2406. # include "CarlaPipeUtils.cpp"

  2407. # include "CarlaProcessUtils.cpp"

  2408. # include "CarlaStateUtils.cpp"

  2409. # include "utils/Information.cpp"

  2410. # include "utils/Windows.cpp"

  2411. #endif /* CARLA_PLUGIN_BUILD */

  2412. 

  2413. // --------------------------------------------------------------------------------------------------------------------