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

2405 lines
86KB
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. #ifdef USING_JUCE

  47. static void carla_standalone_juce_init(void);

  48. static void carla_standalone_juce_idle(void);

  49. static void carla_standalone_juce_cleanup(void);

  50. # define carla_juce_init carla_standalone_juce_init

  51. # define carla_juce_idle carla_standalone_juce_idle

  52. # define carla_juce_cleanup carla_standalone_juce_cleanup

  53. # include "utils/JUCE.cpp"

  54. # undef carla_juce_init

  55. # undef carla_juce_idle

  56. # undef carla_juce_cleanup

  57. #endif

  58. 

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

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

  61. 

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

  63. 

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

  65. {

  66.     if (charPtr == nullptr)

  67.         charPtr = gNullCharPtr;

  68. }

  69. 

  70. // -------------------------------------------------------------------------------------------------------------------

  71. // Constructors

  72. 

  73. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  74.     : type(CB::PLUGIN_NONE),

  75.       category(CB::PLUGIN_CATEGORY_NONE),

  76.       hints(0x0),

  77.       optionsAvailable(0x0),

  78.       optionsEnabled(0x0),

  79.       filename(gNullCharPtr),

  80.       name(gNullCharPtr),

  81.       label(gNullCharPtr),

  82.       maker(gNullCharPtr),

  83.       copyright(gNullCharPtr),

  84.       iconName(gNullCharPtr),

  85.       uniqueId(0) {}

  86. 

  87. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  88. {

  89.     if (label != gNullCharPtr)

  90.         delete[] label;

  91.     if (maker != gNullCharPtr)

  92.         delete[] maker;

  93.     if (copyright != gNullCharPtr)

  94.         delete[] copyright;

  95. }

  96. 

  97. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  98.     : name(gNullCharPtr),

  99.       symbol(gNullCharPtr),

  100.       unit(gNullCharPtr),

  101.       comment(gNullCharPtr),

  102.       groupName(gNullCharPtr),

  103.       scalePointCount(0) {}

  104. 

  105. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  106. {

  107.     if (name != gNullCharPtr)

  108.         delete[] name;

  109.     if (symbol != gNullCharPtr)

  110.         delete[] symbol;

  111.     if (unit != gNullCharPtr)

  112.         delete[] unit;

  113.     if (comment != gNullCharPtr)

  114.         delete[] comment;

  115.     if (groupName != gNullCharPtr)

  116.         delete[] groupName;

  117. }

  118. 

  119. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  120.     : value(0.0f),

  121.       label(gNullCharPtr) {}

  122. 

  123. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  124. {

  125.     if (label != gNullCharPtr)

  126.         delete[] label;

  127. }

  128. 

  129. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  130.     : playing(false),

  131.       frame(0),

  132.       bar(0),

  133.       beat(0),

  134.       tick(0),

  135.       bpm(0.0) {}

  136. 

  137. void _CarlaTransportInfo::clear() noexcept

  138. {

  139.     playing = false;

  140.     frame = 0;

  141.     bar = 0;

  142.     beat = 0;

  143.     tick = 0;

  144.     bpm = 0.0;

  145. }

  146. 

  147. // --------------------------------------------------------------------------------------------------------------------

  148. 

  149. using CarlaBackend::CarlaPluginPtr;

  150. 

  151. // --------------------------------------------------------------------------------------------------------------------

  152. 

  153. uint carla_get_engine_driver_count()

  154. {

  155.     carla_debug("carla_get_engine_driver_count()");

  156. 

  157.     return CarlaEngine::getDriverCount();

  158. }

  159. 

  160. const char* carla_get_engine_driver_name(uint index)

  161. {

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

  163. 

  164.     return CarlaEngine::getDriverName(index);

  165. }

  166. 

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

  168. {

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

  170. 

  171.     return CarlaEngine::getDriverDeviceNames(index);

  172. }

  173. 

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

  175. {

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

  177. 

  178.     static EngineDriverDeviceInfo retDevInfo;

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

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

  181. 

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

  183. 

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

  185.     {

  186.         retDevInfo.hints       =  devInfo->hints;

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

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

  189.     }

  190.     else

  191.     {

  192.         retDevInfo.hints       = 0x0;

  193.         retDevInfo.bufferSizes = nullBufferSizes;

  194.         retDevInfo.sampleRates = nullSampleRates;

  195.     }

  196. 

  197.     return &retDevInfo;

  198. }

  199. 

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

  201. {

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

  203. }

  204. 

  205. // --------------------------------------------------------------------------------------------------------------------

  206. 

  207. CarlaHostHandle carla_standalone_host_init(void)

  208. {

  209. #ifdef CARLA_OS_UNIX

  210.     static const ThreadSafeFFTW sThreadSafeFFTW;

  211. #endif

  212. 

  213.     static CarlaHostStandalone gStandalone;

  214. 

  215.     return &gStandalone;

  216. }

  217. 

  218. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  219. {

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

  221. 

  222.     return handle->engine;

  223. }

  224. 

  225. // --------------------------------------------------------------------------------------------------------------------

  226. 

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

  228. {

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

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

  231. 

  232.     using water::File;

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

  234. 

  235. #ifdef BUILD_BRIDGE

  236.     /*

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

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

  239. 

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

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

  242. 

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

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

  245.     */

  246. 

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

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

  249. 

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

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

  252. 

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

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

  255. 

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

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

  258. 

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

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

  261. 

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

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

  264. 

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

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

  267. 

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

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

  270. 

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

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

  273. 

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

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

  276. 

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

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

  279. 

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

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

  282. 

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

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

  285. 

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

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

  288. 

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

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

  291.     else

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

  293. 

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

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

  296.     else

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

  298. 

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

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

  301. 

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

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

  304. #else

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

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

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

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

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

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

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

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

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

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

  315. 

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

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

  318. 

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

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

  321. 

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

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

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

  325. 

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

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

  328. 

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

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

  331. 

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

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

  334. 

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

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

  337. 

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

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

  340. 

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

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

  343. 

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

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

  346. 

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

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

  349. 

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

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

  352. 

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

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

  355. 

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

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

  358.     else

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

  360. 

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

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

  363. 

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

  365. 

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

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

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

  369. 

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

  371.     {

  372.         char strBuf[STR_MAX+1];

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

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

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

  376.     }

  377.     else

  378.     {

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

  380.     }

  381. 

  382. # ifndef CARLA_OS_WIN

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

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

  385. 

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

  387. 

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

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

  390. 

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

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

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

  394. # endif

  395. 

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

  397. 

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

  399. #endif // BUILD_BRIDGE

  400. }

  401. 

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

  403. {

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

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

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

  407. 

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

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

  410. 

  411. #ifdef CARLA_OS_WIN

  412.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  413. #endif

  414. 

  415. #ifdef USING_JUCE

  416.     carla_standalone_juce_init();

  417. #endif

  418. 

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

  420. 

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

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

  423. 

  424.     shandle.engine = engine;

  425. 

  426. #ifdef BUILD_BRIDGE

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

  428.     {

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

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

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

  432. 

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

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

  435.     }

  436.     else

  437.     {

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

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

  440.     }

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

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

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

  444. #else

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

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

  447. #endif

  448. 

  449.     carla_engine_init_common(shandle, engine);

  450. 

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

  452.     {

  453. #ifndef BUILD_BRIDGE

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

  455.             shandle.logThread.init();

  456. #endif

  457.         shandle.lastError = "No error";

  458.         return true;

  459.     }

  460.     else

  461.     {

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

  463.         shandle.engine = nullptr;

  464.         delete engine;

  465. #ifdef USING_JUCE

  466.         carla_standalone_juce_cleanup();

  467. #endif

  468.         return false;

  469.     }

  470. }

  471. 

  472. #ifdef BUILD_BRIDGE

  473. bool carla_engine_init_bridge(CarlaHostHandle handle,

  474.                               const char audioBaseName[6+1],

  475.                               const char rtClientBaseName[6+1],

  476.                               const char nonRtClientBaseName[6+1],

  477.                               const char nonRtServerBaseName[6+1],

  478.                               const char* const clientName)

  479. {

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

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

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

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

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

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

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

  487. 

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

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

  490. 

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

  492.                                                                      rtClientBaseName,

  493.                                                                      nonRtClientBaseName,

  494.                                                                      nonRtServerBaseName));

  495. 

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

  497. 

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

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

  500. 

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

  502. 

  503.     carla_engine_init_common(shandle, engine);

  504. 

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

  506.     {

  507.         shandle.lastError = "No error";

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

  509.         return true;

  510.     }

  511.     else

  512.     {

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

  514.         return false;

  515.     }

  516. }

  517. #endif

  518. 

  519. bool carla_engine_close(CarlaHostHandle handle)

  520. {

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

  522. 

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

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

  525. 

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

  527. 

  528.     CarlaEngine* const engine = shandle.engine;

  529. 

  530.     engine->setAboutToClose();

  531.     engine->removeAllPlugins();

  532. 

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

  534. 

  535.     if (! closed)

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

  537. 

  538. #ifndef BUILD_BRIDGE

  539.     shandle.logThread.stop();

  540. #endif

  541. 

  542.     shandle.engine = nullptr;

  543.     delete engine;

  544. 

  545. #ifdef USING_JUCE

  546.     carla_standalone_juce_cleanup();

  547. #endif

  548.     return closed;

  549. }

  550. 

  551. void carla_engine_idle(CarlaHostHandle handle)

  552. {

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

  554. 

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

  556. 

  557. #ifdef USING_JUCE

  558.     if (handle->isStandalone)

  559.         carla_standalone_juce_idle();

  560. #endif

  561. }

  562. 

  563. bool carla_is_engine_running(CarlaHostHandle handle)

  564. {

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

  566. }

  567. 

  568. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  569. {

  570.     static CarlaRuntimeEngineInfo retInfo;

  571. 

  572.     // reset

  573.     retInfo.load = 0.0f;

  574.     retInfo.xruns = 0;

  575. 

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

  577. 

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

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

  580. 

  581.     return &retInfo;

  582. }

  583. 

  584. #ifndef BUILD_BRIDGE

  585. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  586. {

  587.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  588. 

  589.     // reset

  590.     retInfo.name = gNullCharPtr;

  591.     retInfo.hints = 0x0;

  592.     retInfo.bufferSize = 0;

  593.     retInfo.bufferSizes = nullptr;

  594.     retInfo.sampleRate = 0.0;

  595.     retInfo.sampleRates = nullptr;

  596. 

  597.     const char* audioDriver;

  598.     const char* audioDevice;

  599. 

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

  601.     {

  602.         audioDriver = engine->getCurrentDriverName();

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

  604. 

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

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

  607.     }

  608.     else if (handle->isStandalone)

  609.     {

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

  611. 

  612.         audioDriver = shandle.engineOptions.audioDriver;

  613.         audioDevice = shandle.engineOptions.audioDevice;

  614. 

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

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

  617.     }

  618.     else

  619.     {

  620.         return &retInfo;

  621.     }

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

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

  624. 

  625.     uint index = 0;

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

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

  628.     {

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

  630.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  631. 

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

  633.             break;

  634.     }

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

  636. 

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

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

  639. 

  640.     retInfo.name        = audioDevice;

  641.     retInfo.hints       = devInfo->hints;

  642.     retInfo.bufferSizes = devInfo->bufferSizes;

  643.     retInfo.sampleRates = devInfo->sampleRates;

  644. 

  645.     return &retInfo;

  646. }

  647. 

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

  649. {

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

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

  652. 

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

  654. }

  655. 

  656. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  657. {

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

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

  660. 

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

  662. }

  663. #endif // BUILD_BRIDGE

  664. 

  665. void carla_clear_engine_xruns(CarlaHostHandle handle)

  666. {

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

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

  669. }

  670. 

  671. void carla_cancel_engine_action(CarlaHostHandle handle)

  672. {

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

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

  675. }

  676. 

  677. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  678. {

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

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

  681. 

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

  683. }

  684. 

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

  686. {

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

  688. 

  689.     if (handle->isStandalone)

  690.     {

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

  692. 

  693.         shandle.engineCallback    = func;

  694.         shandle.engineCallbackPtr = ptr;

  695. 

  696. #ifndef BUILD_BRIDGE

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

  698. #endif

  699.     }

  700. 

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

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

  703. }

  704. 

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

  706. {

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

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

  709. 

  710.     if (handle->isStandalone)

  711.     {

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

  713. 

  714.         switch (option)

  715.         {

  716.         case CB::ENGINE_OPTION_DEBUG:

  717.             break;

  718. 

  719.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  722.             break;

  723. 

  724.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  726. 

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

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

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

  730.             {

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

  732. 

  733.                 if (shandle.engineCallback != nullptr)

  734.                     shandle.engineCallback(shandle.engineCallbackPtr,

  735.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  736.                                            0,

  737.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  738.                                            0, 0, 0.0f,

  739.                                            shandle.engineOptions.transportExtra);

  740.             }

  741.             else

  742.             {

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

  744.             }

  745. 

  746.             delete[] shandle.engineOptions.transportExtra;

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

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

  749.             else

  750.                 shandle.engineOptions.transportExtra = nullptr;

  751.             break;

  752. 

  753.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  756.             break;

  757. 

  758.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  761.             break;

  762. 

  763.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  766.             break;

  767. 

  768.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  771.             break;

  772. 

  773.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  774.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  776.             break;

  777. 

  778.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  781.             break;

  782. 

  783.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  784.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  786.             break;

  787. 

  788.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  789.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  791.             break;

  792. 

  793.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  794.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  796.             break;

  797. 

  798.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  801.             break;

  802. 

  803.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  804.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  805. 

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

  807.                 delete[] shandle.engineOptions.audioDriver;

  808. 

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

  810.             break;

  811. 

  812.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  813.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  814. 

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

  816.                 delete[] shandle.engineOptions.audioDevice;

  817. 

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

  819.             break;

  820. 

  821. #ifndef BUILD_BRIDGE

  822.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  825.             break;

  826. 

  827.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  829.             shandle.engineOptions.oscPortTCP = value;

  830.             break;

  831. 

  832.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  834.             shandle.engineOptions.oscPortUDP = value;

  835.             break;

  836. #endif

  837. 

  838.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  841.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  842. 

  843.             switch (value)

  844.             {

  845.             case CB::FILE_AUDIO:

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

  847.                     delete[] shandle.engineOptions.pathAudio;

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

  849.                 break;

  850.             case CB::FILE_MIDI:

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

  852.                     delete[] shandle.engineOptions.pathMIDI;

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

  854.                 break;

  855.             }

  856.             break;

  857. 

  858.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  861.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  862. 

  863.             switch (value)

  864.             {

  865.             case CB::PLUGIN_LADSPA:

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

  867.                     delete[] shandle.engineOptions.pathLADSPA;

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

  869.                 break;

  870.             case CB::PLUGIN_DSSI:

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

  872.                     delete[] shandle.engineOptions.pathDSSI;

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

  874.                 break;

  875.             case CB::PLUGIN_LV2:

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

  877.                     delete[] shandle.engineOptions.pathLV2;

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

  879.                 break;

  880.             case CB::PLUGIN_VST2:

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

  882.                     delete[] shandle.engineOptions.pathVST2;

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

  884.                 break;

  885.             case CB::PLUGIN_VST3:

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

  887.                     delete[] shandle.engineOptions.pathVST3;

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

  889.                 break;

  890.             case CB::PLUGIN_SF2:

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

  892.                     delete[] shandle.engineOptions.pathSF2;

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

  894.                 break;

  895.             case CB::PLUGIN_SFZ:

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

  897.                     delete[] shandle.engineOptions.pathSFZ;

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

  899.                 break;

  900.             case CB::PLUGIN_JSFX:

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

  902.                     delete[] shandle.engineOptions.pathJSFX;

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

  904.                 break;

  905.             }

  906.             break;

  907. 

  908.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  910. 

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

  912.                 delete[] shandle.engineOptions.binaryDir;

  913. 

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

  915.             break;

  916. 

  917.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  919. 

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

  921.                 delete[] shandle.engineOptions.resourceDir;

  922. 

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

  924.             break;

  925. 

  926.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  929.             break;

  930. 

  931.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  933.             break;

  934. 

  935.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  937.             break;

  938. 

  939.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  940.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  942.             break;

  943. 

  944.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  947.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  949.         }   break;

  950. 

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

  952.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  954. 

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

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

  957. 

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

  959.             break;

  960. 

  961.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  964.             break;

  965. 

  966.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  968. 

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

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

  971. 

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

  973.             break;

  974. 

  975.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  978.             break;

  979. 

  980.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  983.             break;

  984. 

  985.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  988.             break;

  989. #endif

  990. 

  991. #ifndef BUILD_BRIDGE

  992.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  994.             break;

  995. #endif

  996. 

  997.         case CB::ENGINE_OPTION_CLIENT_NAME_PREFIX:

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

  999.                 delete[] shandle.engineOptions.clientNamePrefix;

  1000. 

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

  1002.                                                    ? carla_strdup_safe(valueStr)

  1003.                                                    : nullptr;

  1004.             break;

  1005. 

  1006.         case CB::ENGINE_OPTION_PLUGINS_ARE_STANDALONE:

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

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

  1009.             break;

  1010.         }

  1011.     }

  1012. 

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

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

  1015. }

  1016. 

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

  1018. {

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

  1020. 

  1021.     if (handle->isStandalone)

  1022.     {

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

  1024. 

  1025.         shandle.fileCallback    = func;

  1026.         shandle.fileCallbackPtr = ptr;

  1027.     }

  1028. 

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

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

  1031. }

  1032. 

  1033. // --------------------------------------------------------------------------------------------------------------------

  1034. 

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

  1036. {

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

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

  1039. 

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

  1041. 

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

  1043. }

  1044. 

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

  1046. {

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

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

  1049. 

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

  1051. 

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

  1053. }

  1054. 

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

  1056. {

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

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

  1059. 

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

  1061. 

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

  1063. }

  1064. 

  1065. #ifndef BUILD_BRIDGE

  1066. const char* carla_get_current_project_folder(CarlaHostHandle handle)

  1067. {

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

  1069. 

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

  1071. 

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

  1073.         return ret;

  1074. 

  1075.     return gNullCharPtr;

  1076. }

  1077. 

  1078. const char* carla_get_current_project_filename(CarlaHostHandle handle)

  1079. {

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

  1081. 

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

  1083. 

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

  1085.         return ret;

  1086. 

  1087.     return gNullCharPtr;

  1088. }

  1089. 

  1090. void carla_clear_project_filename(CarlaHostHandle handle)

  1091. {

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

  1093. 

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

  1095. 

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

  1097. }

  1098. 

  1099. // --------------------------------------------------------------------------------------------------------------------

  1100. 

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

  1102. {

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

  1104. 

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

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

  1107. 

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

  1109. }

  1110. 

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

  1112. {

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

  1114. 

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

  1116. 

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

  1118. }

  1119. 

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

  1121. {

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

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

  1124. 

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

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

  1127. 

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

  1129.         return true;

  1130. 

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

  1132. }

  1133. 

  1134. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  1135. {

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

  1137. 

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

  1139. 

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

  1141. }

  1142. 

  1143. // --------------------------------------------------------------------------------------------------------------------

  1144. 

  1145. void carla_transport_play(CarlaHostHandle handle)

  1146. {

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

  1148. 

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

  1150. 

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

  1152. }

  1153. 

  1154. void carla_transport_pause(CarlaHostHandle handle)

  1155. {

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

  1157. 

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

  1159. 

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

  1161. }

  1162. 

  1163. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1164. {

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

  1166. 

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

  1168. 

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

  1170. }

  1171. 

  1172. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1173. {

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

  1175. 

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

  1177. 

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

  1179. }

  1180. 

  1181. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1182. {

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

  1184. 

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

  1186. }

  1187. 

  1188. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1189. {

  1190.     static CarlaTransportInfo retTransInfo;

  1191.     retTransInfo.clear();

  1192. 

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

  1194. 

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

  1196. 

  1197.     retTransInfo.playing = timeInfo.playing;

  1198.     retTransInfo.frame   = timeInfo.frame;

  1199. 

  1200.     if (timeInfo.bbt.valid)

  1201.     {

  1202.         retTransInfo.bar  = timeInfo.bbt.bar;

  1203.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1206.     }

  1207. 

  1208.     return &retTransInfo;

  1209. }

  1210. #endif

  1211. 

  1212. // --------------------------------------------------------------------------------------------------------------------

  1213. 

  1214. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1215. {

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

  1217. 

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

  1219. 

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

  1221. }

  1222. 

  1223. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1224. {

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

  1226. 

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

  1228. 

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

  1230. }

  1231. 

  1232. // --------------------------------------------------------------------------------------------------------------------

  1233. 

  1234. bool carla_add_plugin(CarlaHostHandle handle,

  1235.                       BinaryType btype, PluginType ptype,

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

  1237.                       const void* extraPtr, uint options)

  1238. {

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

  1240. 

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

  1242.                 handle,

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

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

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

  1246. 

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

  1248. }

  1249. 

  1250. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1251. {

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

  1253. 

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

  1255. 

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

  1257. }

  1258. 

  1259. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1260. {

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

  1262. 

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

  1264. 

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

  1266. }

  1267. 

  1268. #ifndef BUILD_BRIDGE

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

  1270. {

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

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

  1273. 

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

  1275. 

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

  1277. }

  1278. 

  1279. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1280. {

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

  1282. 

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

  1284. 

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

  1286. }

  1287. 

  1288. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1289. {

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

  1291. 

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

  1293. 

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

  1295. }

  1296. 

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

  1298. {

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

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

  1301. 

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

  1303. 

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

  1305. }

  1306. #endif

  1307. 

  1308. // --------------------------------------------------------------------------------------------------------------------

  1309. 

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

  1311. {

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

  1313.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1315. 

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

  1317.         return plugin->loadStateFromFile(filename);

  1318. 

  1319.     return false;

  1320. }

  1321. 

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

  1323. {

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

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

  1326. 

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

  1328.         return plugin->saveStateToFile(filename);

  1329. 

  1330.     return false;

  1331. }

  1332. 

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

  1334. {

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

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

  1337. 

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

  1339.         return plugin->exportAsLV2(lv2path);

  1340. 

  1341.     return false;

  1342. }

  1343. 

  1344. // --------------------------------------------------------------------------------------------------------------------

  1345. 

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

  1347. {

  1348.     static CarlaPluginInfo retInfo;

  1349. 

  1350.     // reset

  1351.     retInfo.type             = CB::PLUGIN_NONE;

  1352.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1353.     retInfo.hints            = 0x0;

  1354.     retInfo.optionsAvailable = 0x0;

  1355.     retInfo.optionsEnabled   = 0x0;

  1356.     retInfo.filename         = gNullCharPtr;

  1357.     retInfo.name             = gNullCharPtr;

  1358.     retInfo.iconName         = gNullCharPtr;

  1359.     retInfo.uniqueId         = 0;

  1360. 

  1361.     // cleanup

  1362.     if (retInfo.label != gNullCharPtr)

  1363.     {

  1364.         delete[] retInfo.label;

  1365.         retInfo.label = gNullCharPtr;

  1366.     }

  1367. 

  1368.     if (retInfo.maker != gNullCharPtr)

  1369.     {

  1370.         delete[] retInfo.maker;

  1371.         retInfo.maker = gNullCharPtr;

  1372.     }

  1373. 

  1374.     if (retInfo.copyright != gNullCharPtr)

  1375.     {

  1376.         delete[] retInfo.copyright;

  1377.         retInfo.copyright = gNullCharPtr;

  1378.     }

  1379. 

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

  1381. 

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

  1383.     {

  1384.         char strBuf[STR_MAX+1];

  1385.         carla_zeroChars(strBuf, STR_MAX+1);

  1386. 

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

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

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

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

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

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

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

  1394. 

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

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

  1397. 

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

  1399.             retInfo.label = carla_strdup_safe(strBuf);

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

  1401.             retInfo.maker = carla_strdup_safe(strBuf);

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

  1403.             retInfo.copyright = carla_strdup_safe(strBuf);

  1404. 

  1405.         checkStringPtr(retInfo.filename);

  1406.         checkStringPtr(retInfo.name);

  1407.         checkStringPtr(retInfo.iconName);

  1408.         checkStringPtr(retInfo.label);

  1409.         checkStringPtr(retInfo.maker);

  1410.         checkStringPtr(retInfo.copyright);

  1411.     }

  1412. 

  1413.     return &retInfo;

  1414. }

  1415. 

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

  1417. {

  1418.     static CarlaPortCountInfo retInfo;

  1419.     carla_zeroStruct(retInfo);

  1420. 

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

  1422. 

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

  1424.     {

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

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

  1427.     }

  1428. 

  1429.     return &retInfo;

  1430. }

  1431. 

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

  1433. {

  1434.     static CarlaPortCountInfo retInfo;

  1435.     carla_zeroStruct(retInfo);

  1436. 

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

  1438. 

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

  1440.     {

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

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

  1443.     }

  1444. 

  1445.     return &retInfo;

  1446. }

  1447. 

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

  1449. {

  1450.     static CarlaPortCountInfo retInfo;

  1451.     carla_zeroStruct(retInfo);

  1452. 

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

  1454. 

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

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

  1457. 

  1458.     return &retInfo;

  1459. }

  1460. 

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

  1462. {

  1463.     static CarlaParameterInfo retInfo;

  1464. 

  1465.     // reset

  1466.     retInfo.scalePointCount = 0;

  1467. 

  1468.     // cleanup

  1469.     if (retInfo.name != gNullCharPtr)

  1470.     {

  1471.         delete[] retInfo.name;

  1472.         retInfo.name = gNullCharPtr;

  1473.     }

  1474. 

  1475.     if (retInfo.symbol != gNullCharPtr)

  1476.     {

  1477.         delete[] retInfo.symbol;

  1478.         retInfo.symbol = gNullCharPtr;

  1479.     }

  1480. 

  1481.     if (retInfo.unit != gNullCharPtr)

  1482.     {

  1483.         delete[] retInfo.unit;

  1484.         retInfo.unit = gNullCharPtr;

  1485.     }

  1486. 

  1487.     if (retInfo.comment != gNullCharPtr)

  1488.     {

  1489.         delete[] retInfo.comment;

  1490.         retInfo.comment = gNullCharPtr;

  1491.     }

  1492. 

  1493.     if (retInfo.groupName != gNullCharPtr)

  1494.     {

  1495.         delete[] retInfo.groupName;

  1496.         retInfo.groupName = gNullCharPtr;

  1497.     }

  1498. 

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

  1500. 

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

  1502.     {

  1503.         char strBuf[STR_MAX+1];

  1504.         carla_zeroChars(strBuf, STR_MAX+1);

  1505. 

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

  1507. 

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

  1509.         {

  1510.             retInfo.name = carla_strdup_safe(strBuf);

  1511.             carla_zeroChars(strBuf, STR_MAX+1);

  1512.         }

  1513. 

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

  1515.         {

  1516.             retInfo.symbol = carla_strdup_safe(strBuf);

  1517.             carla_zeroChars(strBuf, STR_MAX+1);

  1518.         }

  1519. 

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

  1521.         {

  1522.             retInfo.unit = carla_strdup_safe(strBuf);

  1523.             carla_zeroChars(strBuf, STR_MAX+1);

  1524.         }

  1525. 

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

  1527.         {

  1528.             retInfo.comment = carla_strdup_safe(strBuf);

  1529.             carla_zeroChars(strBuf, STR_MAX+1);

  1530.         }

  1531. 

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

  1533.         {

  1534.             retInfo.groupName = carla_strdup_safe(strBuf);

  1535.             carla_zeroChars(strBuf, STR_MAX+1);

  1536.         }

  1537. 

  1538.         checkStringPtr(retInfo.name);

  1539.         checkStringPtr(retInfo.symbol);

  1540.         checkStringPtr(retInfo.unit);

  1541.         checkStringPtr(retInfo.comment);

  1542.         checkStringPtr(retInfo.groupName);

  1543.     }

  1544. 

  1545.     return &retInfo;

  1546. }

  1547. 

  1548. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1549.                                                                uint pluginId,

  1550.                                                                uint32_t parameterId,

  1551.                                                                uint32_t scalePointId)

  1552. {

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

  1554. 

  1555.     static CarlaScalePointInfo retInfo;

  1556. 

  1557.     // reset

  1558.     retInfo.value = 0.0f;

  1559. 

  1560.     // cleanup

  1561.     if (retInfo.label != gNullCharPtr)

  1562.     {

  1563.         delete[] retInfo.label;

  1564.         retInfo.label = gNullCharPtr;

  1565.     }

  1566. 

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

  1568. 

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

  1570.     {

  1571.         char strBuf[STR_MAX+1];

  1572. 

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

  1574. 

  1575.         carla_zeroChars(strBuf, STR_MAX+1);

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

  1577.             retInfo.label = carla_strdup_safe(strBuf);

  1578. 

  1579.         checkStringPtr(retInfo.label);

  1580.     }

  1581. 

  1582.     return &retInfo;

  1583. }

  1584. 

  1585. // --------------------------------------------------------------------------------------------------------------------

  1586. 

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

  1588. {

  1589.     static ParameterData retParamData;

  1590. 

  1591.     // reset

  1592.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1593.     retParamData.hints       = 0x0;

  1594.     retParamData.index       = CB::PARAMETER_NULL;

  1595.     retParamData.rindex      = -1;

  1596.     retParamData.midiChannel = 0;

  1597.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1598.     retParamData.mappedMinimum = 0.0f;

  1599.     retParamData.mappedMaximum = 0.0f;

  1600. 

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

  1602. 

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

  1604.     {

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

  1606. 

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

  1608.         retParamData.type        = pluginParamData.type;

  1609.         retParamData.hints       = pluginParamData.hints;

  1610.         retParamData.index       = pluginParamData.index;

  1611.         retParamData.rindex      = pluginParamData.rindex;

  1612.         retParamData.midiChannel = pluginParamData.midiChannel;

  1613.         retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1614.         retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1615.         retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1616.     }

  1617. 

  1618.     return &retParamData;

  1619. }

  1620. 

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

  1622. {

  1623.     static ParameterRanges retParamRanges;

  1624. 

  1625.     // reset

  1626.     retParamRanges.def       = 0.0f;

  1627.     retParamRanges.min       = 0.0f;

  1628.     retParamRanges.max       = 1.0f;

  1629.     retParamRanges.step      = 0.01f;

  1630.     retParamRanges.stepSmall = 0.0001f;

  1631.     retParamRanges.stepLarge = 0.1f;

  1632. 

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

  1634. 

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

  1636.     {

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

  1638. 

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

  1640.         retParamRanges.def       = pluginParamRanges.def;

  1641.         retParamRanges.min       = pluginParamRanges.min;

  1642.         retParamRanges.max       = pluginParamRanges.max;

  1643.         retParamRanges.step      = pluginParamRanges.step;

  1644.         retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1645.         retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1646.     }

  1647. 

  1648.     return &retParamRanges;

  1649. }

  1650. 

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

  1652. {

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

  1654. 

  1655.     // reset

  1656.     retMidiProgData.bank    = 0;

  1657.     retMidiProgData.program = 0;

  1658. 

  1659.     if (retMidiProgData.name != gNullCharPtr)

  1660.     {

  1661.         delete[] retMidiProgData.name;

  1662.         retMidiProgData.name = gNullCharPtr;

  1663.     }

  1664. 

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

  1666. 

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

  1668.     {

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

  1670. 

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

  1672.         retMidiProgData.bank    = pluginMidiProgData.bank;

  1673.         retMidiProgData.program = pluginMidiProgData.program;

  1674. 

  1675.         if (pluginMidiProgData.name != nullptr)

  1676.         {

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

  1678.             checkStringPtr(retMidiProgData.name);

  1679.         }

  1680.         else

  1681.         {

  1682.             retMidiProgData.name = gNullCharPtr;

  1683.         }

  1684.     }

  1685. 

  1686.     return &retMidiProgData;

  1687. }

  1688. 

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

  1690. {

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

  1692. 

  1693.     // reset

  1694.     if (retCustomData.type != gNullCharPtr)

  1695.     {

  1696.         delete[] retCustomData.type;

  1697.         retCustomData.type = gNullCharPtr;

  1698.     }

  1699. 

  1700.     if (retCustomData.key != gNullCharPtr)

  1701.     {

  1702.         delete[] retCustomData.key;

  1703.         retCustomData.key = gNullCharPtr;

  1704.     }

  1705. 

  1706.     if (retCustomData.value != gNullCharPtr)

  1707.     {

  1708.         delete[] retCustomData.value;

  1709.         retCustomData.value = gNullCharPtr;

  1710.     }

  1711. 

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

  1713. 

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

  1715.     {

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

  1717. 

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

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

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

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

  1722.         checkStringPtr(retCustomData.type);

  1723.         checkStringPtr(retCustomData.key);

  1724.         checkStringPtr(retCustomData.value);

  1725.     }

  1726. 

  1727.     return &retCustomData;

  1728. }

  1729. 

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

  1731. {

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

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

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

  1735. 

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

  1737.     {

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

  1739. 

  1740.         if (count == 0)

  1741.             return gNullCharPtr;

  1742. 

  1743.         static CarlaString customDataValue;

  1744. 

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

  1746.         {

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

  1748. 

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

  1750.                 continue;

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

  1752.                 continue;

  1753. 

  1754.             customDataValue = pluginCustomData.value;

  1755.             return customDataValue.buffer();

  1756.         }

  1757.     }

  1758. 

  1759.     return gNullCharPtr;

  1760. }

  1761. 

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

  1763. {

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

  1765. 

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

  1767.     {

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

  1769. 

  1770.         void* data = nullptr;

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

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

  1773. 

  1774.         static CarlaString chunkData;

  1775. 

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

  1777.         return chunkData.buffer();

  1778.     }

  1779. 

  1780.     return gNullCharPtr;

  1781. }

  1782. 

  1783. // --------------------------------------------------------------------------------------------------------------------

  1784. 

  1785. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1786. {

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

  1788. 

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

  1790.         return plugin->getParameterCount();

  1791. 

  1792.     return 0;

  1793. }

  1794. 

  1795. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1796. {

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

  1798. 

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

  1800.         return plugin->getProgramCount();

  1801. 

  1802.     return 0;

  1803. }

  1804. 

  1805. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1806. {

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

  1808. 

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

  1810.         return plugin->getMidiProgramCount();

  1811. 

  1812.     return 0;

  1813. }

  1814. 

  1815. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1816. {

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

  1818. 

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

  1820.         return plugin->getCustomDataCount();

  1821. 

  1822.     return 0;

  1823. }

  1824. 

  1825. // --------------------------------------------------------------------------------------------------------------------

  1826. 

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

  1828. {

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

  1830. 

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

  1832.     {

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

  1834. 

  1835.         static char textBuf[STR_MAX+1];

  1836.         carla_zeroChars(textBuf, STR_MAX+1);

  1837. 

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

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

  1840. 

  1841.         return textBuf;

  1842.     }

  1843. 

  1844.     return gNullCharPtr;

  1845. }

  1846. 

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

  1848. {

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

  1850. 

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

  1852.     {

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

  1854. 

  1855.         static char programName[STR_MAX+1];

  1856.         carla_zeroChars(programName, STR_MAX+1);

  1857. 

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

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

  1860. 

  1861.         return programName;

  1862.     }

  1863. 

  1864.     return gNullCharPtr;

  1865. }

  1866. 

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

  1868. {

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

  1870. 

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

  1872.     {

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

  1874. 

  1875.         static char midiProgramName[STR_MAX+1];

  1876.         carla_zeroChars(midiProgramName, STR_MAX+1);

  1877. 

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

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

  1880. 

  1881.         return midiProgramName;

  1882.     }

  1883. 

  1884.     return gNullCharPtr;

  1885. }

  1886. 

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

  1888. {

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

  1890. 

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

  1892.     {

  1893.         static char realPluginName[STR_MAX+1];

  1894.         carla_zeroChars(realPluginName, STR_MAX+1);

  1895. 

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

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

  1898. 

  1899.         return realPluginName;

  1900.     }

  1901. 

  1902.     return gNullCharPtr;

  1903. }

  1904. 

  1905. // --------------------------------------------------------------------------------------------------------------------

  1906. 

  1907. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1908. {

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

  1910. 

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

  1912.         return plugin->getCurrentProgram();

  1913. 

  1914.     return -1;

  1915. }

  1916. 

  1917. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1918. {

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

  1920. 

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

  1922.         return plugin->getCurrentMidiProgram();

  1923. 

  1924.     return -1;

  1925. }

  1926. 

  1927. // --------------------------------------------------------------------------------------------------------------------

  1928. 

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

  1930. {

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

  1932. 

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

  1934.     {

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

  1936. 

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

  1938.     }

  1939. 

  1940.     return 0.0f;

  1941. }

  1942. 

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

  1944. {

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

  1946. 

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

  1948.     {

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

  1950. 

  1951.         return plugin->getParameterValue(parameterId);

  1952.     }

  1953. 

  1954.     return 0.0f;

  1955. }

  1956. 

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

  1958. {

  1959. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1961. #else

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

  1963. #endif

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

  1965. 

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

  1967.         return plugin->getInternalParameterValue(parameterId);

  1968. 

  1969.     return 0.0f;

  1970. }

  1971. 

  1972. // --------------------------------------------------------------------------------------------------------------------

  1973. 

  1974. uint32_t carla_get_plugin_latency(CarlaHostHandle handle, uint pluginId)

  1975. {

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

  1977. 

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

  1979.          return plugin->getLatencyInFrames();

  1980. 

  1981.     return 0;

  1982. }

  1983. 

  1984. // --------------------------------------------------------------------------------------------------------------------

  1985. 

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

  1987. {

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

  1989. 

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

  1991. }

  1992. 

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

  1994. {

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

  1996. 

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

  1998. }

  1999. 

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

  2001. {

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

  2003. 

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

  2005. }

  2006. 

  2007. // --------------------------------------------------------------------------------------------------------------------

  2008. 

  2009. CARLA_BACKEND_START_NAMESPACE

  2010. 

  2011. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2012. // defined in CarlaPluginInternal.cpp

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

  2014. #endif

  2015. 

  2016. // defined in CarlaPluginLV2.cpp

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

  2018. 

  2019. CARLA_BACKEND_END_NAMESPACE

  2020. 

  2021. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  2022.                                                                   uint pluginId,

  2023.                                                                   uint32_t width, uint32_t height)

  2024. {

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

  2026. 

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

  2028.         return nullptr;

  2029. 

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

  2031.     {

  2032.         switch (plugin->getType())

  2033.         {

  2034. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  2035.         case CB::PLUGIN_INTERNAL:

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

  2037. #endif

  2038.         case CB::PLUGIN_LV2:

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

  2040.         default:

  2041.             return nullptr;

  2042.         }

  2043.     }

  2044. 

  2045.     return nullptr;

  2046. }

  2047. 

  2048. // --------------------------------------------------------------------------------------------------------------------

  2049. 

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

  2051. {

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

  2053. 

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

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

  2056. }

  2057. 

  2058. #ifndef BUILD_BRIDGE

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

  2060. {

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

  2062. 

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

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

  2065. }

  2066. 

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

  2068. {

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

  2070. 

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

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

  2073. }

  2074. 

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

  2076. {

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

  2078. 

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

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

  2081. }

  2082. 

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

  2084. {

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

  2086. 

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

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

  2089. }

  2090. 

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

  2092. {

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

  2094. 

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

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

  2097. }

  2098. 

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

  2100. {

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

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

  2103. 

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

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

  2106. }

  2107. #endif

  2108. 

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

  2110. {

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

  2112. 

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

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

  2115. }

  2116. 

  2117. // --------------------------------------------------------------------------------------------------------------------

  2118. 

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

  2120. {

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

  2122. 

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

  2124.     {

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

  2126. 

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

  2128.     }

  2129. }

  2130. 

  2131. #ifndef BUILD_BRIDGE

  2132. 

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

  2134. {

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

  2136.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2137. 

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

  2139.     {

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

  2141. 

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

  2143.     }

  2144. }

  2145. 

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

  2147. {

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

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

  2150. 

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

  2152.     {

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

  2154. 

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

  2156.     }

  2157. }

  2158. 

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

  2160. {

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

  2162. 

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

  2164.     {

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

  2166. 

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

  2168.     }

  2169. }

  2170. 

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

  2172. {

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

  2174. 

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

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

  2177. }

  2178. #endif

  2179. 

  2180. // --------------------------------------------------------------------------------------------------------------------

  2181. 

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

  2183. {

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

  2185. 

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

  2187.     {

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

  2189. 

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

  2191.     }

  2192. }

  2193. 

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

  2195. {

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

  2197. 

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

  2199.     {

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

  2201. 

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

  2203.     }

  2204. }

  2205. 

  2206. // --------------------------------------------------------------------------------------------------------------------

  2207. 

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

  2209. {

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

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

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

  2213.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2214. 

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

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

  2217. }

  2218. 

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

  2220. {

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

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

  2223. 

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

  2225.     {

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

  2227. 

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

  2229. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2231. #else

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

  2233. #endif

  2234.     }

  2235. }

  2236. 

  2237. // --------------------------------------------------------------------------------------------------------------------

  2238. 

  2239. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2240. {

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

  2242. 

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

  2244.         plugin->prepareForSave(false);

  2245. }

  2246. 

  2247. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2248. {

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

  2250. 

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

  2252.         plugin->resetParameters();

  2253. }

  2254. 

  2255. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2256. {

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

  2258. 

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

  2260.         plugin->randomizeParameters();

  2261. }

  2262. 

  2263. #ifndef BUILD_BRIDGE

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

  2265. {

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

  2267. 

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

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

  2270. }

  2271. #endif

  2272. 

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

  2274. {

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

  2276.     CARLA_SAFE_ASSERT_RETURN(title != nullptr,);

  2277. 

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

  2279.         plugin->setCustomUITitle(title);

  2280. }

  2281. 

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

  2283. {

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

  2285. 

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

  2287.         plugin->showCustomUI(yesNo);

  2288. }

  2289. 

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

  2291. {

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

  2293. 

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

  2295.         return plugin->embedCustomUI(ptr);

  2296. 

  2297.     return nullptr;

  2298. }

  2299. 

  2300. // --------------------------------------------------------------------------------------------------------------------

  2301. 

  2302. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2303. {

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

  2305. 

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

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

  2308. }

  2309. 

  2310. double carla_get_sample_rate(CarlaHostHandle handle)

  2311. {

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

  2313. 

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

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

  2316. }

  2317. 

  2318. // --------------------------------------------------------------------------------------------------------------------

  2319. 

  2320. const char* carla_get_last_error(CarlaHostHandle handle)

  2321. {

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

  2323. 

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

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

  2326. 

  2327.     return handle->isStandalone

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

  2329.            : gNullCharPtr;

  2330. }

  2331. 

  2332. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2333. {

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

  2335. 

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

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

  2338.     {

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

  2340.         if (handle->isStandalone)

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

  2342.         return gNullCharPtr;

  2343.     }

  2344. 

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

  2346. 

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

  2348.         return path;

  2349. 

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

  2351.     return notAvailable;

  2352. #else

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

  2354. 

  2355.     // unused

  2356.     (void)handle;

  2357. #endif

  2358. }

  2359. 

  2360. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2361. {

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

  2363. 

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

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

  2366.     {

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

  2368.         if (handle->isStandalone)

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

  2370.         return gNullCharPtr;

  2371.     }

  2372. 

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

  2374. 

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

  2376.         return path;

  2377. 

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

  2379.     return notAvailable;

  2380. #else

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

  2382. 

  2383.     // unused

  2384.     (void)handle;

  2385. #endif

  2386. }

  2387. 

  2388. // --------------------------------------------------------------------------------------------------------------------

  2389. 

  2390. #ifndef CARLA_PLUGIN_EXPORT

  2391. # define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2392. # include "CarlaPluginUI.cpp"

  2393. # undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2394. # include "CarlaDssiUtils.cpp"

  2395. # include "CarlaMacUtils.cpp"

  2396. # include "CarlaPatchbayUtils.cpp"

  2397. # include "CarlaPipeUtils.cpp"

  2398. # include "CarlaProcessUtils.cpp"

  2399. # include "CarlaStateUtils.cpp"

  2400. # include "utils/Information.cpp"

  2401. # include "utils/Windows.cpp"

  2402. #endif /* CARLA_PLUGIN_EXPORT */

  2403. 

  2404. // --------------------------------------------------------------------------------------------------------------------