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

2380 lines
85KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHostImpl.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngineInit.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. #ifndef BUILD_BRIDGE

  31. # include "CarlaLogThread.hpp"

  32. #endif

  33. 

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

  35. 

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

  37.     if (! (cond)) {                                              \

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

  39.         if (handle->isStandalone)                                \

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

  41.         return ret;                                              \

  42.     }

  43. 

  44. // --------------------------------------------------------------------------------------------------------------------

  45. 

  46. static void carla_standalone_juce_init(void);

  47. static void carla_standalone_juce_idle(void);

  48. static void carla_standalone_juce_cleanup(void);

  49. #define carla_juce_init carla_standalone_juce_init

  50. #define carla_juce_idle carla_standalone_juce_idle

  51. #define carla_juce_cleanup carla_standalone_juce_cleanup

  52. #include "utils/JUCE.cpp"

  53. #undef carla_juce_init

  54. #undef carla_juce_idle

  55. #undef carla_juce_cleanup

  56. 

  57. // -------------------------------------------------------------------------------------------------------------------

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

  59. 

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

  61. 

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

  63. {

  64.     if (charPtr == nullptr)

  65.         charPtr = gNullCharPtr;

  66. }

  67. 

  68. // -------------------------------------------------------------------------------------------------------------------

  69. // Constructors

  70. 

  71. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  72.     : type(CB::PLUGIN_NONE),

  73.       category(CB::PLUGIN_CATEGORY_NONE),

  74.       hints(0x0),

  75.       optionsAvailable(0x0),

  76.       optionsEnabled(0x0),

  77.       filename(gNullCharPtr),

  78.       name(gNullCharPtr),

  79.       label(gNullCharPtr),

  80.       maker(gNullCharPtr),

  81.       copyright(gNullCharPtr),

  82.       iconName(gNullCharPtr),

  83.       uniqueId(0) {}

  84. 

  85. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  86. {

  87.     if (label != gNullCharPtr)

  88.         delete[] label;

  89.     if (maker != gNullCharPtr)

  90.         delete[] maker;

  91.     if (copyright != gNullCharPtr)

  92.         delete[] copyright;

  93. }

  94. 

  95. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  96.     : name(gNullCharPtr),

  97.       symbol(gNullCharPtr),

  98.       unit(gNullCharPtr),

  99.       comment(gNullCharPtr),

  100.       groupName(gNullCharPtr),

  101.       scalePointCount(0) {}

  102. 

  103. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  104. {

  105.     if (name != gNullCharPtr)

  106.         delete[] name;

  107.     if (symbol != gNullCharPtr)

  108.         delete[] symbol;

  109.     if (unit != gNullCharPtr)

  110.         delete[] unit;

  111.     if (comment != gNullCharPtr)

  112.         delete[] comment;

  113.     if (groupName != gNullCharPtr)

  114.         delete[] groupName;

  115. }

  116. 

  117. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  118.     : value(0.0f),

  119.       label(gNullCharPtr) {}

  120. 

  121. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  122. {

  123.     if (label != gNullCharPtr)

  124.         delete[] label;

  125. }

  126. 

  127. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  128.     : playing(false),

  129.       frame(0),

  130.       bar(0),

  131.       beat(0),

  132.       tick(0),

  133.       bpm(0.0) {}

  134. 

  135. void _CarlaTransportInfo::clear() noexcept

  136. {

  137.     playing = false;

  138.     frame = 0;

  139.     bar = 0;

  140.     beat = 0;

  141.     tick = 0;

  142.     bpm = 0.0;

  143. }

  144. 

  145. // --------------------------------------------------------------------------------------------------------------------

  146. 

  147. using CarlaBackend::CarlaPluginPtr;

  148. 

  149. // --------------------------------------------------------------------------------------------------------------------

  150. 

  151. uint carla_get_engine_driver_count()

  152. {

  153.     carla_debug("carla_get_engine_driver_count()");

  154. 

  155.     return CarlaEngine::getDriverCount();

  156. }

  157. 

  158. const char* carla_get_engine_driver_name(uint index)

  159. {

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

  161. 

  162.     return CarlaEngine::getDriverName(index);

  163. }

  164. 

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

  166. {

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

  168. 

  169.     return CarlaEngine::getDriverDeviceNames(index);

  170. }

  171. 

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

  173. {

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

  175. 

  176.     static EngineDriverDeviceInfo retDevInfo;

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

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

  179. 

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

  181. 

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

  183.     {

  184.         retDevInfo.hints       =  devInfo->hints;

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

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

  187.     }

  188.     else

  189.     {

  190.         retDevInfo.hints       = 0x0;

  191.         retDevInfo.bufferSizes = nullBufferSizes;

  192.         retDevInfo.sampleRates = nullSampleRates;

  193.     }

  194. 

  195.     return &retDevInfo;

  196. }

  197. 

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

  199. {

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

  201. }

  202. 

  203. // --------------------------------------------------------------------------------------------------------------------

  204. 

  205. CarlaHostHandle carla_standalone_host_init(void)

  206. {

  207. #ifdef CARLA_OS_UNIX

  208.     static const ThreadSafeFFTW sThreadSafeFFTW;

  209. #endif

  210. 

  211.     static CarlaHostStandalone gStandalone;

  212. 

  213.     return &gStandalone;

  214. }

  215. 

  216. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  217. {

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

  219. 

  220.     return handle->engine;

  221. }

  222. 

  223. // --------------------------------------------------------------------------------------------------------------------

  224. 

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

  226. {

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

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

  229. 

  230.     using water::File;

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

  232. 

  233. #ifdef BUILD_BRIDGE

  234.     /*

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

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

  237. 

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

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

  240. 

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

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

  243.     */

  244. 

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

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

  247. 

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

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

  250. 

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

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

  253. 

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

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

  256. 

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

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

  259. 

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

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

  262. 

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

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

  265. 

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

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

  268. 

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

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

  271. 

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

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

  274. 

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

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

  277. 

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

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

  280. 

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

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

  283. 

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

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

  286.     else

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

  288. 

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

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

  291.     else

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

  293. 

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

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

  296. 

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

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

  299. #else

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

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

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

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

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

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

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

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

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

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

  310. 

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

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

  313. 

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

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

  316. 

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

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

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

  320. 

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

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

  323. 

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

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

  326. 

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

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

  329. 

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

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

  332. 

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

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

  335. 

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

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

  338. 

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

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

  341. 

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

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

  344. 

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

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

  347. 

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

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

  350.     else

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

  352. 

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

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

  355. 

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

  357. 

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

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

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

  361. 

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

  363.     {

  364.         char strBuf[STR_MAX+1];

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

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

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

  368.     }

  369.     else

  370.     {

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

  372.     }

  373. 

  374. # ifndef CARLA_OS_WIN

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

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

  377. 

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

  379. 

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

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

  382. 

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

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

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

  386. # endif

  387. 

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

  389. 

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

  391. #endif // BUILD_BRIDGE

  392. }

  393. 

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

  395. {

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

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

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

  399. 

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

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

  402. 

  403. #ifdef CARLA_OS_WIN

  404.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  405. #endif

  406. 

  407. #ifdef USING_JUCE

  408.     carla_standalone_juce_init();

  409. #endif

  410. 

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

  412. 

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

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

  415. 

  416.     shandle.engine = engine;

  417. 

  418. #ifdef BUILD_BRIDGE

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

  420.     {

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

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

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

  424. 

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

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

  427.     }

  428.     else

  429.     {

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

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

  432.     }

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

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

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

  436. #else

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

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

  439. #endif

  440. 

  441.     carla_engine_init_common(shandle, engine);

  442. 

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

  444.     {

  445. #ifndef BUILD_BRIDGE

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

  447.             shandle.logThread.init();

  448. #endif

  449.         shandle.lastError = "No error";

  450.         return true;

  451.     }

  452.     else

  453.     {

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

  455.         shandle.engine = nullptr;

  456.         delete engine;

  457. #ifdef USING_JUCE

  458.         carla_standalone_juce_cleanup();

  459. #endif

  460.         return false;

  461.     }

  462. }

  463. 

  464. #ifdef BUILD_BRIDGE

  465. bool carla_engine_init_bridge(CarlaHostHandle handle,

  466.                               const char audioBaseName[6+1],

  467.                               const char rtClientBaseName[6+1],

  468.                               const char nonRtClientBaseName[6+1],

  469.                               const char nonRtServerBaseName[6+1],

  470.                               const char* const clientName)

  471. {

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

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

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

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

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

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

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

  479. 

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

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

  482. 

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

  484.                                                                      rtClientBaseName,

  485.                                                                      nonRtClientBaseName,

  486.                                                                      nonRtServerBaseName));

  487. 

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

  489. 

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

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

  492. 

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

  494. 

  495.     carla_engine_init_common(shandle, engine);

  496. 

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

  498.     {

  499.         shandle.lastError = "No error";

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

  501.         return true;

  502.     }

  503.     else

  504.     {

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

  506.         return false;

  507.     }

  508. }

  509. #endif

  510. 

  511. bool carla_engine_close(CarlaHostHandle handle)

  512. {

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

  514. 

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

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

  517. 

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

  519. 

  520.     CarlaEngine* const engine = shandle.engine;

  521. 

  522.     engine->setAboutToClose();

  523.     engine->removeAllPlugins();

  524. 

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

  526. 

  527.     if (! closed)

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

  529. 

  530. #ifndef BUILD_BRIDGE

  531.     shandle.logThread.stop();

  532. #endif

  533. 

  534.     shandle.engine = nullptr;

  535.     delete engine;

  536. 

  537. #ifdef USING_JUCE

  538.     carla_standalone_juce_cleanup();

  539. #endif

  540.     return closed;

  541. }

  542. 

  543. void carla_engine_idle(CarlaHostHandle handle)

  544. {

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

  546. 

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

  548. 

  549. #ifdef USING_JUCE

  550.     if (handle->isStandalone)

  551.         carla_standalone_juce_idle();

  552. #endif

  553. }

  554. 

  555. bool carla_is_engine_running(CarlaHostHandle handle)

  556. {

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

  558. }

  559. 

  560. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  561. {

  562.     static CarlaRuntimeEngineInfo retInfo;

  563. 

  564.     // reset

  565.     retInfo.load = 0.0f;

  566.     retInfo.xruns = 0;

  567. 

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

  569. 

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

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

  572. 

  573.     return &retInfo;

  574. }

  575. 

  576. #ifndef BUILD_BRIDGE

  577. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  578. {

  579.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  580. 

  581.     // reset

  582.     retInfo.name = gNullCharPtr;

  583.     retInfo.hints = 0x0;

  584.     retInfo.bufferSize = 0;

  585.     retInfo.bufferSizes = nullptr;

  586.     retInfo.sampleRate = 0.0;

  587.     retInfo.sampleRates = nullptr;

  588. 

  589.     const char* audioDriver;

  590.     const char* audioDevice;

  591. 

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

  593.     {

  594.         audioDriver = engine->getCurrentDriverName();

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

  596. 

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

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

  599.     }

  600.     else if (handle->isStandalone)

  601.     {

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

  603. 

  604.         audioDriver = shandle.engineOptions.audioDriver;

  605.         audioDevice = shandle.engineOptions.audioDevice;

  606. 

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

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

  609.     }

  610.     else

  611.     {

  612.         return &retInfo;

  613.     }

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

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

  616. 

  617.     uint index = 0;

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

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

  620.     {

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

  622.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  623. 

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

  625.             break;

  626.     }

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

  628. 

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

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

  631. 

  632.     retInfo.name        = audioDevice;

  633.     retInfo.hints       = devInfo->hints;

  634.     retInfo.bufferSizes = devInfo->bufferSizes;

  635.     retInfo.sampleRates = devInfo->sampleRates;

  636. 

  637.     return &retInfo;

  638. }

  639. 

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

  641. {

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

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

  644. 

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

  646. }

  647. 

  648. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  649. {

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

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

  652. 

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

  654. }

  655. #endif // BUILD_BRIDGE

  656. 

  657. void carla_clear_engine_xruns(CarlaHostHandle handle)

  658. {

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

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

  661. }

  662. 

  663. void carla_cancel_engine_action(CarlaHostHandle handle)

  664. {

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

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

  667. }

  668. 

  669. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  670. {

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

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

  673. 

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

  675. }

  676. 

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

  678. {

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

  680. 

  681.     if (handle->isStandalone)

  682.     {

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

  684. 

  685.         shandle.engineCallback    = func;

  686.         shandle.engineCallbackPtr = ptr;

  687. 

  688. #ifndef BUILD_BRIDGE

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

  690. #endif

  691.     }

  692. 

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

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

  695. }

  696. 

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

  698. {

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

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

  701. 

  702.     if (handle->isStandalone)

  703.     {

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

  705. 

  706.         switch (option)

  707.         {

  708.         case CB::ENGINE_OPTION_DEBUG:

  709.             break;

  710. 

  711.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  714.             break;

  715. 

  716.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  718. 

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

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

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

  722.             {

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

  724. 

  725.                 if (shandle.engineCallback != nullptr)

  726.                     shandle.engineCallback(shandle.engineCallbackPtr,

  727.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  728.                                            0,

  729.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  730.                                            0, 0, 0.0f,

  731.                                            shandle.engineOptions.transportExtra);

  732.             }

  733.             else

  734.             {

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

  736.             }

  737. 

  738.             delete[] shandle.engineOptions.transportExtra;

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

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

  741.             else

  742.                 shandle.engineOptions.transportExtra = nullptr;

  743.             break;

  744. 

  745.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  748.             break;

  749. 

  750.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  753.             break;

  754. 

  755.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  758.             break;

  759. 

  760.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  763.             break;

  764. 

  765.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  766.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  768.             break;

  769. 

  770.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  773.             break;

  774. 

  775.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  776.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  778.             break;

  779. 

  780.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  781.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  783.             break;

  784. 

  785.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  786.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  788.             break;

  789. 

  790.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  793.             break;

  794. 

  795.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  796.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  797. 

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

  799.                 delete[] shandle.engineOptions.audioDriver;

  800. 

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

  802.             break;

  803. 

  804.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  805.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  806. 

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

  808.                 delete[] shandle.engineOptions.audioDevice;

  809. 

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

  811.             break;

  812. 

  813. #ifndef BUILD_BRIDGE

  814.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  817.             break;

  818. 

  819.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  821.             shandle.engineOptions.oscPortTCP = value;

  822.             break;

  823. 

  824.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  826.             shandle.engineOptions.oscPortUDP = value;

  827.             break;

  828. #endif

  829. 

  830.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  833.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  834. 

  835.             switch (value)

  836.             {

  837.             case CB::FILE_AUDIO:

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

  839.                     delete[] shandle.engineOptions.pathAudio;

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

  841.                 break;

  842.             case CB::FILE_MIDI:

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

  844.                     delete[] shandle.engineOptions.pathMIDI;

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

  846.                 break;

  847.             }

  848.             break;

  849. 

  850.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

  852.             CARLA_SAFE_ASSERT_RETURN(value <= CB::PLUGIN_SFZ,);

  853.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  854. 

  855.             switch (value)

  856.             {

  857.             case CB::PLUGIN_LADSPA:

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

  859.                     delete[] shandle.engineOptions.pathLADSPA;

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

  861.                 break;

  862.             case CB::PLUGIN_DSSI:

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

  864.                     delete[] shandle.engineOptions.pathDSSI;

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

  866.                 break;

  867.             case CB::PLUGIN_LV2:

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

  869.                     delete[] shandle.engineOptions.pathLV2;

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

  871.                 break;

  872.             case CB::PLUGIN_VST2:

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

  874.                     delete[] shandle.engineOptions.pathVST2;

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

  876.                 break;

  877.             case CB::PLUGIN_VST3:

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

  879.                     delete[] shandle.engineOptions.pathVST3;

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

  881.                 break;

  882.             case CB::PLUGIN_SF2:

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

  884.                     delete[] shandle.engineOptions.pathSF2;

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

  886.                 break;

  887.             case CB::PLUGIN_SFZ:

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

  889.                     delete[] shandle.engineOptions.pathSFZ;

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

  891.                 break;

  892.             }

  893.             break;

  894. 

  895.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  897. 

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

  899.                 delete[] shandle.engineOptions.binaryDir;

  900. 

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

  902.             break;

  903. 

  904.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  906. 

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

  908.                 delete[] shandle.engineOptions.resourceDir;

  909. 

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

  911.             break;

  912. 

  913.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  916.             break;

  917. 

  918.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  920.             break;

  921. 

  922.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  924.             break;

  925. 

  926.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  927.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  929.             break;

  930. 

  931.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  934.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  936.         }   break;

  937. 

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

  939.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  941. 

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

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

  944. 

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

  946.             break;

  947. 

  948.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  951.             break;

  952. 

  953.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  955. 

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

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

  958. 

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

  960.             break;

  961. 

  962.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  965.             break;

  966. 

  967.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  970.             break;

  971. 

  972.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  975.             break;

  976. #endif

  977. 

  978. #ifndef BUILD_BRIDGE

  979.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  981.             break;

  982. #endif

  983. 

  984.         case CB::ENGINE_OPTION_CLIENT_NAME_PREFIX:

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

  986.                 delete[] shandle.engineOptions.clientNamePrefix;

  987. 

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

  989.                                                    ? carla_strdup_safe(valueStr)

  990.                                                    : nullptr;

  991.             break;

  992. 

  993.         case CB::ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

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

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

  996.             break;

  997.         }

  998.     }

  999. 

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

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

  1002. }

  1003. 

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

  1005. {

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

  1007. 

  1008.     if (handle->isStandalone)

  1009.     {

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

  1011. 

  1012.         shandle.fileCallback    = func;

  1013.         shandle.fileCallbackPtr = ptr;

  1014.     }

  1015. 

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

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

  1018. }

  1019. 

  1020. // --------------------------------------------------------------------------------------------------------------------

  1021. 

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

  1023. {

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

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

  1026. 

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

  1028. 

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

  1030. }

  1031. 

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

  1033. {

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

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

  1036. 

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

  1038. 

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

  1040. }

  1041. 

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

  1043. {

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

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

  1046. 

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

  1048. 

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

  1050. }

  1051. 

  1052. #ifndef BUILD_BRIDGE

  1053. const char* carla_get_current_project_folder(CarlaHostHandle handle)

  1054. {

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

  1056. 

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

  1058. 

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

  1060.         return ret;

  1061. 

  1062.     return gNullCharPtr;

  1063. }

  1064. 

  1065. const char* carla_get_current_project_filename(CarlaHostHandle handle)

  1066. {

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

  1068. 

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

  1070. 

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

  1072.         return ret;

  1073. 

  1074.     return gNullCharPtr;

  1075. }

  1076. 

  1077. void carla_clear_project_filename(CarlaHostHandle handle)

  1078. {

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

  1080. 

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

  1082. 

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

  1084. }

  1085. 

  1086. // --------------------------------------------------------------------------------------------------------------------

  1087. 

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

  1089. {

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

  1091. 

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

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

  1094. 

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

  1096. }

  1097. 

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

  1099. {

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

  1101. 

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

  1103. 

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

  1105. }

  1106. 

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

  1108. {

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

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

  1111. 

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

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

  1114. 

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

  1116.         return true;

  1117. 

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

  1119. }

  1120. 

  1121. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  1122. {

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

  1124. 

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

  1126. 

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

  1128. }

  1129. 

  1130. // --------------------------------------------------------------------------------------------------------------------

  1131. 

  1132. void carla_transport_play(CarlaHostHandle handle)

  1133. {

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

  1135. 

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

  1137. 

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

  1139. }

  1140. 

  1141. void carla_transport_pause(CarlaHostHandle handle)

  1142. {

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

  1144. 

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

  1146. 

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

  1148. }

  1149. 

  1150. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1151. {

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

  1153. 

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

  1155. 

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

  1157. }

  1158. 

  1159. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1160. {

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

  1162. 

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

  1164. 

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

  1166. }

  1167. 

  1168. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1169. {

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

  1171. 

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

  1173. }

  1174. 

  1175. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1176. {

  1177.     static CarlaTransportInfo retTransInfo;

  1178.     retTransInfo.clear();

  1179. 

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

  1181. 

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

  1183. 

  1184.     retTransInfo.playing = timeInfo.playing;

  1185.     retTransInfo.frame   = timeInfo.frame;

  1186. 

  1187.     if (timeInfo.bbt.valid)

  1188.     {

  1189.         retTransInfo.bar  = timeInfo.bbt.bar;

  1190.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1193.     }

  1194. 

  1195.     return &retTransInfo;

  1196. }

  1197. #endif

  1198. 

  1199. // --------------------------------------------------------------------------------------------------------------------

  1200. 

  1201. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1202. {

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

  1204. 

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

  1206. 

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

  1208. }

  1209. 

  1210. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1211. {

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

  1213. 

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

  1215. 

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

  1217. }

  1218. 

  1219. // --------------------------------------------------------------------------------------------------------------------

  1220. 

  1221. bool carla_add_plugin(CarlaHostHandle handle,

  1222.                       BinaryType btype, PluginType ptype,

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

  1224.                       const void* extraPtr, uint options)

  1225. {

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

  1227. 

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

  1229.                 handle,

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

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

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

  1233. 

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

  1235. }

  1236. 

  1237. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1238. {

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

  1240. 

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

  1242. 

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

  1244. }

  1245. 

  1246. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1247. {

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

  1249. 

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

  1251. 

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

  1253. }

  1254. 

  1255. #ifndef BUILD_BRIDGE

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

  1257. {

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

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

  1260. 

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

  1262. 

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

  1264. }

  1265. 

  1266. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1267. {

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

  1269. 

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

  1271. 

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

  1273. }

  1274. 

  1275. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1276. {

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

  1278. 

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

  1280. 

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

  1282. }

  1283. 

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

  1285. {

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

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

  1288. 

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

  1290. 

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

  1292. }

  1293. #endif

  1294. 

  1295. // --------------------------------------------------------------------------------------------------------------------

  1296. 

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

  1298. {

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

  1300.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1302. 

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

  1304.         return plugin->loadStateFromFile(filename);

  1305. 

  1306.     return false;

  1307. }

  1308. 

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

  1310. {

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

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

  1313. 

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

  1315.         return plugin->saveStateToFile(filename);

  1316. 

  1317.     return false;

  1318. }

  1319. 

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

  1321. {

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

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

  1324. 

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

  1326.         return plugin->exportAsLV2(lv2path);

  1327. 

  1328.     return false;

  1329. }

  1330. 

  1331. // --------------------------------------------------------------------------------------------------------------------

  1332. 

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

  1334. {

  1335.     static CarlaPluginInfo retInfo;

  1336. 

  1337.     // reset

  1338.     retInfo.type             = CB::PLUGIN_NONE;

  1339.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1340.     retInfo.hints            = 0x0;

  1341.     retInfo.optionsAvailable = 0x0;

  1342.     retInfo.optionsEnabled   = 0x0;

  1343.     retInfo.filename         = gNullCharPtr;

  1344.     retInfo.name             = gNullCharPtr;

  1345.     retInfo.iconName         = gNullCharPtr;

  1346.     retInfo.uniqueId         = 0;

  1347. 

  1348.     // cleanup

  1349.     if (retInfo.label != gNullCharPtr)

  1350.     {

  1351.         delete[] retInfo.label;

  1352.         retInfo.label = gNullCharPtr;

  1353.     }

  1354. 

  1355.     if (retInfo.maker != gNullCharPtr)

  1356.     {

  1357.         delete[] retInfo.maker;

  1358.         retInfo.maker = gNullCharPtr;

  1359.     }

  1360. 

  1361.     if (retInfo.copyright != gNullCharPtr)

  1362.     {

  1363.         delete[] retInfo.copyright;

  1364.         retInfo.copyright = gNullCharPtr;

  1365.     }

  1366. 

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

  1368. 

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

  1370.     {

  1371.         char strBuf[STR_MAX+1];

  1372.         carla_zeroChars(strBuf, STR_MAX+1);

  1373. 

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

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

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

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

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

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

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

  1381. 

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

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

  1384. 

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

  1386.             retInfo.label = carla_strdup_safe(strBuf);

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

  1388.             retInfo.maker = carla_strdup_safe(strBuf);

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

  1390.             retInfo.copyright = carla_strdup_safe(strBuf);

  1391. 

  1392.         checkStringPtr(retInfo.filename);

  1393.         checkStringPtr(retInfo.name);

  1394.         checkStringPtr(retInfo.iconName);

  1395.         checkStringPtr(retInfo.label);

  1396.         checkStringPtr(retInfo.maker);

  1397.         checkStringPtr(retInfo.copyright);

  1398.     }

  1399. 

  1400.     return &retInfo;

  1401. }

  1402. 

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

  1404. {

  1405.     static CarlaPortCountInfo retInfo;

  1406.     carla_zeroStruct(retInfo);

  1407. 

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

  1409. 

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

  1411.     {

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

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

  1414.     }

  1415. 

  1416.     return &retInfo;

  1417. }

  1418. 

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

  1420. {

  1421.     static CarlaPortCountInfo retInfo;

  1422.     carla_zeroStruct(retInfo);

  1423. 

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

  1425. 

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

  1427.     {

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

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

  1430.     }

  1431. 

  1432.     return &retInfo;

  1433. }

  1434. 

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

  1436. {

  1437.     static CarlaPortCountInfo retInfo;

  1438.     carla_zeroStruct(retInfo);

  1439. 

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

  1441. 

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

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

  1444. 

  1445.     return &retInfo;

  1446. }

  1447. 

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

  1449. {

  1450.     static CarlaParameterInfo retInfo;

  1451. 

  1452.     // reset

  1453.     retInfo.scalePointCount = 0;

  1454. 

  1455.     // cleanup

  1456.     if (retInfo.name != gNullCharPtr)

  1457.     {

  1458.         delete[] retInfo.name;

  1459.         retInfo.name = gNullCharPtr;

  1460.     }

  1461. 

  1462.     if (retInfo.symbol != gNullCharPtr)

  1463.     {

  1464.         delete[] retInfo.symbol;

  1465.         retInfo.symbol = gNullCharPtr;

  1466.     }

  1467. 

  1468.     if (retInfo.unit != gNullCharPtr)

  1469.     {

  1470.         delete[] retInfo.unit;

  1471.         retInfo.unit = gNullCharPtr;

  1472.     }

  1473. 

  1474.     if (retInfo.comment != gNullCharPtr)

  1475.     {

  1476.         delete[] retInfo.comment;

  1477.         retInfo.comment = gNullCharPtr;

  1478.     }

  1479. 

  1480.     if (retInfo.groupName != gNullCharPtr)

  1481.     {

  1482.         delete[] retInfo.groupName;

  1483.         retInfo.groupName = gNullCharPtr;

  1484.     }

  1485. 

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

  1487. 

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

  1489.     {

  1490.         char strBuf[STR_MAX+1];

  1491.         carla_zeroChars(strBuf, STR_MAX+1);

  1492. 

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

  1494. 

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

  1496.         {

  1497.             retInfo.name = carla_strdup_safe(strBuf);

  1498.             carla_zeroChars(strBuf, STR_MAX+1);

  1499.         }

  1500. 

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

  1502.         {

  1503.             retInfo.symbol = carla_strdup_safe(strBuf);

  1504.             carla_zeroChars(strBuf, STR_MAX+1);

  1505.         }

  1506. 

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

  1508.         {

  1509.             retInfo.unit = carla_strdup_safe(strBuf);

  1510.             carla_zeroChars(strBuf, STR_MAX+1);

  1511.         }

  1512. 

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

  1514.         {

  1515.             retInfo.comment = carla_strdup_safe(strBuf);

  1516.             carla_zeroChars(strBuf, STR_MAX+1);

  1517.         }

  1518. 

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

  1520.         {

  1521.             retInfo.groupName = carla_strdup_safe(strBuf);

  1522.             carla_zeroChars(strBuf, STR_MAX+1);

  1523.         }

  1524. 

  1525.         checkStringPtr(retInfo.name);

  1526.         checkStringPtr(retInfo.symbol);

  1527.         checkStringPtr(retInfo.unit);

  1528.         checkStringPtr(retInfo.comment);

  1529.         checkStringPtr(retInfo.groupName);

  1530.     }

  1531. 

  1532.     return &retInfo;

  1533. }

  1534. 

  1535. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1536.                                                                uint pluginId,

  1537.                                                                uint32_t parameterId,

  1538.                                                                uint32_t scalePointId)

  1539. {

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

  1541. 

  1542.     static CarlaScalePointInfo retInfo;

  1543. 

  1544.     // reset

  1545.     retInfo.value = 0.0f;

  1546. 

  1547.     // cleanup

  1548.     if (retInfo.label != gNullCharPtr)

  1549.     {

  1550.         delete[] retInfo.label;

  1551.         retInfo.label = gNullCharPtr;

  1552.     }

  1553. 

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

  1555. 

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

  1557.     {

  1558.         char strBuf[STR_MAX+1];

  1559. 

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

  1561. 

  1562.         carla_zeroChars(strBuf, STR_MAX+1);

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

  1564.             retInfo.label = carla_strdup_safe(strBuf);

  1565. 

  1566.         checkStringPtr(retInfo.label);

  1567.     }

  1568. 

  1569.     return &retInfo;

  1570. }

  1571. 

  1572. // --------------------------------------------------------------------------------------------------------------------

  1573. 

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

  1575. {

  1576.     static ParameterData retParamData;

  1577. 

  1578.     // reset

  1579.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1580.     retParamData.hints       = 0x0;

  1581.     retParamData.index       = CB::PARAMETER_NULL;

  1582.     retParamData.rindex      = -1;

  1583.     retParamData.midiChannel = 0;

  1584.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1585.     retParamData.mappedMinimum = 0.0f;

  1586.     retParamData.mappedMaximum = 0.0f;

  1587. 

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

  1589. 

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

  1591.     {

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

  1593. 

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

  1595.         retParamData.type        = pluginParamData.type;

  1596.         retParamData.hints       = pluginParamData.hints;

  1597.         retParamData.index       = pluginParamData.index;

  1598.         retParamData.rindex      = pluginParamData.rindex;

  1599.         retParamData.midiChannel = pluginParamData.midiChannel;

  1600.         retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1601.         retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1602.         retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1603.     }

  1604. 

  1605.     return &retParamData;

  1606. }

  1607. 

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

  1609. {

  1610.     static ParameterRanges retParamRanges;

  1611. 

  1612.     // reset

  1613.     retParamRanges.def       = 0.0f;

  1614.     retParamRanges.min       = 0.0f;

  1615.     retParamRanges.max       = 1.0f;

  1616.     retParamRanges.step      = 0.01f;

  1617.     retParamRanges.stepSmall = 0.0001f;

  1618.     retParamRanges.stepLarge = 0.1f;

  1619. 

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

  1621. 

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

  1623.     {

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

  1625. 

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

  1627.         retParamRanges.def       = pluginParamRanges.def;

  1628.         retParamRanges.min       = pluginParamRanges.min;

  1629.         retParamRanges.max       = pluginParamRanges.max;

  1630.         retParamRanges.step      = pluginParamRanges.step;

  1631.         retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1632.         retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1633.     }

  1634. 

  1635.     return &retParamRanges;

  1636. }

  1637. 

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

  1639. {

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

  1641. 

  1642.     // reset

  1643.     retMidiProgData.bank    = 0;

  1644.     retMidiProgData.program = 0;

  1645. 

  1646.     if (retMidiProgData.name != gNullCharPtr)

  1647.     {

  1648.         delete[] retMidiProgData.name;

  1649.         retMidiProgData.name = gNullCharPtr;

  1650.     }

  1651. 

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

  1653. 

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

  1655.     {

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

  1657. 

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

  1659.         retMidiProgData.bank    = pluginMidiProgData.bank;

  1660.         retMidiProgData.program = pluginMidiProgData.program;

  1661. 

  1662.         if (pluginMidiProgData.name != nullptr)

  1663.         {

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

  1665.             checkStringPtr(retMidiProgData.name);

  1666.         }

  1667.         else

  1668.         {

  1669.             retMidiProgData.name = gNullCharPtr;

  1670.         }

  1671.     }

  1672. 

  1673.     return &retMidiProgData;

  1674. }

  1675. 

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

  1677. {

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

  1679. 

  1680.     // reset

  1681.     if (retCustomData.type != gNullCharPtr)

  1682.     {

  1683.         delete[] retCustomData.type;

  1684.         retCustomData.type = gNullCharPtr;

  1685.     }

  1686. 

  1687.     if (retCustomData.key != gNullCharPtr)

  1688.     {

  1689.         delete[] retCustomData.key;

  1690.         retCustomData.key = gNullCharPtr;

  1691.     }

  1692. 

  1693.     if (retCustomData.value != gNullCharPtr)

  1694.     {

  1695.         delete[] retCustomData.value;

  1696.         retCustomData.value = gNullCharPtr;

  1697.     }

  1698. 

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

  1700. 

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

  1702.     {

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

  1704. 

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

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

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

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

  1709.         checkStringPtr(retCustomData.type);

  1710.         checkStringPtr(retCustomData.key);

  1711.         checkStringPtr(retCustomData.value);

  1712.     }

  1713. 

  1714.     return &retCustomData;

  1715. }

  1716. 

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

  1718. {

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

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

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

  1722. 

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

  1724.     {

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

  1726. 

  1727.         if (count == 0)

  1728.             return gNullCharPtr;

  1729. 

  1730.         static CarlaString customDataValue;

  1731. 

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

  1733.         {

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

  1735. 

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

  1737.                 continue;

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

  1739.                 continue;

  1740. 

  1741.             customDataValue = pluginCustomData.value;

  1742.             return customDataValue.buffer();

  1743.         }

  1744.     }

  1745. 

  1746.     return gNullCharPtr;

  1747. }

  1748. 

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

  1750. {

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

  1752. 

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

  1754.     {

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

  1756. 

  1757.         void* data = nullptr;

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

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

  1760. 

  1761.         static CarlaString chunkData;

  1762. 

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

  1764.         return chunkData.buffer();

  1765.     }

  1766. 

  1767.     return gNullCharPtr;

  1768. }

  1769. 

  1770. // --------------------------------------------------------------------------------------------------------------------

  1771. 

  1772. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1773. {

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

  1775. 

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

  1777.         return plugin->getParameterCount();

  1778. 

  1779.     return 0;

  1780. }

  1781. 

  1782. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1783. {

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

  1785. 

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

  1787.         return plugin->getProgramCount();

  1788. 

  1789.     return 0;

  1790. }

  1791. 

  1792. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1793. {

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

  1795. 

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

  1797.         return plugin->getMidiProgramCount();

  1798. 

  1799.     return 0;

  1800. }

  1801. 

  1802. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1803. {

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

  1805. 

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

  1807.         return plugin->getCustomDataCount();

  1808. 

  1809.     return 0;

  1810. }

  1811. 

  1812. // --------------------------------------------------------------------------------------------------------------------

  1813. 

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

  1815. {

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

  1817. 

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

  1819.     {

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

  1821. 

  1822.         static char textBuf[STR_MAX+1];

  1823.         carla_zeroChars(textBuf, STR_MAX+1);

  1824. 

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

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

  1827. 

  1828.         return textBuf;

  1829.     }

  1830. 

  1831.     return gNullCharPtr;

  1832. }

  1833. 

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

  1835. {

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

  1837. 

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

  1839.     {

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

  1841. 

  1842.         static char programName[STR_MAX+1];

  1843.         carla_zeroChars(programName, STR_MAX+1);

  1844. 

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

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

  1847. 

  1848.         return programName;

  1849.     }

  1850. 

  1851.     return gNullCharPtr;

  1852. }

  1853. 

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

  1855. {

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

  1857. 

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

  1859.     {

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

  1861. 

  1862.         static char midiProgramName[STR_MAX+1];

  1863.         carla_zeroChars(midiProgramName, STR_MAX+1);

  1864. 

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

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

  1867. 

  1868.         return midiProgramName;

  1869.     }

  1870. 

  1871.     return gNullCharPtr;

  1872. }

  1873. 

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

  1875. {

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

  1877. 

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

  1879.     {

  1880.         static char realPluginName[STR_MAX+1];

  1881.         carla_zeroChars(realPluginName, STR_MAX+1);

  1882. 

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

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

  1885. 

  1886.         return realPluginName;

  1887.     }

  1888. 

  1889.     return gNullCharPtr;

  1890. }

  1891. 

  1892. // --------------------------------------------------------------------------------------------------------------------

  1893. 

  1894. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1895. {

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

  1897. 

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

  1899.         return plugin->getCurrentProgram();

  1900. 

  1901.     return -1;

  1902. }

  1903. 

  1904. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1905. {

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

  1907. 

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

  1909.         return plugin->getCurrentMidiProgram();

  1910. 

  1911.     return -1;

  1912. }

  1913. 

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

  1915. 

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

  1917. {

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

  1919. 

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

  1921.     {

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

  1923. 

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

  1925.     }

  1926. 

  1927.     return 0.0f;

  1928. }

  1929. 

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

  1931. {

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

  1933. 

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

  1935.     {

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

  1937. 

  1938.         return plugin->getParameterValue(parameterId);

  1939.     }

  1940. 

  1941.     return 0.0f;

  1942. }

  1943. 

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

  1945. {

  1946. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1948. #else

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

  1950. #endif

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

  1952. 

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

  1954.         return plugin->getInternalParameterValue(parameterId);

  1955. 

  1956.     return 0.0f;

  1957. }

  1958. 

  1959. // --------------------------------------------------------------------------------------------------------------------

  1960. 

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

  1962. {

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

  1964. 

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

  1966. }

  1967. 

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

  1969. {

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

  1971. 

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

  1973. }

  1974. 

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

  1976. {

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

  1978. 

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

  1980. }

  1981. 

  1982. // --------------------------------------------------------------------------------------------------------------------

  1983. 

  1984. CARLA_BACKEND_START_NAMESPACE

  1985. 

  1986. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1987. // defined in CarlaPluginInternal.cpp

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

  1989. #endif

  1990. 

  1991. // defined in CarlaPluginLV2.cpp

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

  1993. 

  1994. CARLA_BACKEND_END_NAMESPACE

  1995. 

  1996. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  1997.                                                                   uint pluginId,

  1998.                                                                   uint32_t width, uint32_t height)

  1999. {

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

  2001. 

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

  2003.         return nullptr;

  2004. 

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

  2006.     {

  2007.         switch (plugin->getType())

  2008.         {

  2009. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2010.         case CB::PLUGIN_INTERNAL:

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

  2012. #endif

  2013.         case CB::PLUGIN_LV2:

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

  2015.         default:

  2016.             return nullptr;

  2017.         }

  2018.     }

  2019. 

  2020.     return nullptr;

  2021. }

  2022. 

  2023. // --------------------------------------------------------------------------------------------------------------------

  2024. 

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

  2026. {

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

  2028. 

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

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

  2031. }

  2032. 

  2033. #ifndef BUILD_BRIDGE

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

  2035. {

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

  2037. 

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

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

  2040. }

  2041. 

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

  2043. {

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

  2045. 

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

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

  2048. }

  2049. 

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

  2051. {

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

  2053. 

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

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

  2056. }

  2057. 

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

  2059. {

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

  2061. 

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

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

  2064. }

  2065. 

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

  2067. {

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

  2069. 

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

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

  2072. }

  2073. 

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

  2075. {

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

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

  2078. 

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

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

  2081. }

  2082. #endif

  2083. 

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

  2085. {

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

  2087. 

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

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

  2090. }

  2091. 

  2092. // --------------------------------------------------------------------------------------------------------------------

  2093. 

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

  2095. {

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

  2097. 

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

  2099.     {

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

  2101. 

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

  2103.     }

  2104. }

  2105. 

  2106. #ifndef BUILD_BRIDGE

  2107. 

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

  2109. {

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

  2111.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2112. 

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

  2114.     {

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

  2116. 

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

  2118.     }

  2119. }

  2120. 

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

  2122. {

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

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

  2125. 

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

  2127.     {

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

  2129. 

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

  2131.     }

  2132. }

  2133. 

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

  2135. {

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

  2137. 

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

  2139.     {

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

  2141. 

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

  2143.     }

  2144. }

  2145. 

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

  2147. {

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

  2149. 

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

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

  2152. }

  2153. #endif

  2154. 

  2155. // --------------------------------------------------------------------------------------------------------------------

  2156. 

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

  2158. {

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

  2160. 

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

  2162.     {

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

  2164. 

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

  2166.     }

  2167. }

  2168. 

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

  2170. {

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

  2172. 

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

  2174.     {

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

  2176. 

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

  2178.     }

  2179. }

  2180. 

  2181. // --------------------------------------------------------------------------------------------------------------------

  2182. 

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

  2184. {

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

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

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

  2188.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2189. 

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

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

  2192. }

  2193. 

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

  2195. {

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

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

  2198. 

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

  2200.     {

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

  2202. 

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

  2204. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2206. #else

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

  2208. #endif

  2209.     }

  2210. }

  2211. 

  2212. // --------------------------------------------------------------------------------------------------------------------

  2213. 

  2214. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2215. {

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

  2217. 

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

  2219.         plugin->prepareForSave(false);

  2220. }

  2221. 

  2222. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2223. {

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

  2225. 

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

  2227.         plugin->resetParameters();

  2228. }

  2229. 

  2230. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2231. {

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

  2233. 

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

  2235.         plugin->randomizeParameters();

  2236. }

  2237. 

  2238. #ifndef BUILD_BRIDGE

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

  2240. {

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

  2242. 

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

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

  2245. }

  2246. #endif

  2247. 

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

  2249. {

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

  2251.     CARLA_SAFE_ASSERT_RETURN(title != nullptr,);

  2252. 

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

  2254.         plugin->setCustomUITitle(title);

  2255. }

  2256. 

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

  2258. {

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

  2260. 

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

  2262.         plugin->showCustomUI(yesNo);

  2263. }

  2264. 

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

  2266. {

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

  2268. 

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

  2270.         return plugin->embedCustomUI(ptr);

  2271. 

  2272.     return nullptr;

  2273. }

  2274. 

  2275. // --------------------------------------------------------------------------------------------------------------------

  2276. 

  2277. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2278. {

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

  2280. 

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

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

  2283. }

  2284. 

  2285. double carla_get_sample_rate(CarlaHostHandle handle)

  2286. {

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

  2288. 

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

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

  2291. }

  2292. 

  2293. // --------------------------------------------------------------------------------------------------------------------

  2294. 

  2295. const char* carla_get_last_error(CarlaHostHandle handle)

  2296. {

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

  2298. 

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

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

  2301. 

  2302.     return handle->isStandalone

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

  2304.            : gNullCharPtr;

  2305. }

  2306. 

  2307. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2308. {

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

  2310. 

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

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

  2313.     {

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

  2315.         if (handle->isStandalone)

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

  2317.         return gNullCharPtr;

  2318.     }

  2319. 

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

  2321. 

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

  2323.         return path;

  2324. 

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

  2326.     return notAvailable;

  2327. #else

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

  2329. 

  2330.     // unused

  2331.     (void)handle;

  2332. #endif

  2333. }

  2334. 

  2335. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2336. {

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

  2338. 

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

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

  2341.     {

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

  2343.         if (handle->isStandalone)

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

  2345.         return gNullCharPtr;

  2346.     }

  2347. 

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

  2349. 

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

  2351.         return path;

  2352. 

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

  2354.     return notAvailable;

  2355. #else

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

  2357. 

  2358.     // unused

  2359.     (void)handle;

  2360. #endif

  2361. }

  2362. 

  2363. // --------------------------------------------------------------------------------------------------------------------

  2364. 

  2365. #ifndef CARLA_PLUGIN_EXPORT

  2366. # define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2367. # include "CarlaPluginUI.cpp"

  2368. # undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2369. # include "CarlaDssiUtils.cpp"

  2370. # include "CarlaMacUtils.cpp"

  2371. # include "CarlaPatchbayUtils.cpp"

  2372. # include "CarlaPipeUtils.cpp"

  2373. # include "CarlaProcessUtils.cpp"

  2374. # include "CarlaStateUtils.cpp"

  2375. # include "utils/Information.cpp"

  2376. # include "utils/Windows.cpp"

  2377. #endif /* CARLA_PLUGIN_EXPORT */

  2378. 

  2379. // --------------------------------------------------------------------------------------------------------------------