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

2297 lines
86KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHostImpl.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngineInit.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #ifdef BUILD_BRIDGE

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

  33. #else

  34. # include "CarlaLogThread.hpp"

  35. #endif

  36. 

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

  38.     if (! (cond)) {                                              \

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

  40.         if (handle->isStandalone)                                \

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

  42.         return ret;                                              \

  43.     }

  44. 

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

  46. // API

  47. 

  48. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  49. #include "CarlaHostCommon.cpp"

  50. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  51. 

  52. #ifdef USING_JUCE

  53. static void carla_juce_init();

  54. static void carla_juce_idle();

  55. static void carla_juce_cleanup();

  56. # include "utils/JUCE.cpp"

  57. #endif

  58. 

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

  60. 

  61. uint carla_get_engine_driver_count()

  62. {

  63.     carla_debug("carla_get_engine_driver_count()");

  64. 

  65.     return CarlaEngine::getDriverCount();

  66. }

  67. 

  68. const char* carla_get_engine_driver_name(uint index)

  69. {

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

  71. 

  72.     return CarlaEngine::getDriverName(index);

  73. }

  74. 

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

  76. {

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

  78. 

  79.     return CarlaEngine::getDriverDeviceNames(index);

  80. }

  81. 

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

  83. {

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

  85. 

  86.     static EngineDriverDeviceInfo retDevInfo;

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

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

  89. 

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

  91. 

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

  93.     {

  94.         retDevInfo.hints       =  devInfo->hints;

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

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

  97.     }

  98.     else

  99.     {

  100.         retDevInfo.hints       = 0x0;

  101.         retDevInfo.bufferSizes = nullBufferSizes;

  102.         retDevInfo.sampleRates = nullSampleRates;

  103.     }

  104. 

  105.     return &retDevInfo;

  106. }

  107. 

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

  109. {

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

  111. }

  112. 

  113. // --------------------------------------------------------------------------------------------------------------------

  114. 

  115. CarlaHostHandle carla_standalone_host_init(void)

  116. {

  117. #ifdef CARLA_OS_UNIX

  118.     static const ThreadSafeFFTW sThreadSafeFFTW;

  119. #endif

  120. 

  121.     static CarlaHostStandalone gStandalone;

  122. 

  123.     return &gStandalone;

  124. }

  125. 

  126. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  127. {

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

  129. 

  130.     return handle->engine;

  131. }

  132. 

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

  134. 

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

  136. {

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

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

  139. 

  140.     using water::File;

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

  142. 

  143. #ifdef BUILD_BRIDGE

  144.     /*

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

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

  147. 

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

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

  150. 

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

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

  153.     */

  154. 

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

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

  157. 

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

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

  160. 

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

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

  163. 

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

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

  166. 

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

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

  169. 

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

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

  172. 

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

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

  175. 

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

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

  178. 

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

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

  181. 

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

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

  184. 

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

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

  187. 

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

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

  190. 

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

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

  193. 

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

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

  196.     else

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

  198. 

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

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

  201.     else

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

  203. 

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

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

  206. 

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

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

  209. #else

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

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

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

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

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

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

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

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

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

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

  220. 

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

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

  223. 

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

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

  226. 

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

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

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

  230. 

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

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

  233. 

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

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

  236. 

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

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

  239. 

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

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

  242. 

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

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

  245. 

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

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

  248. 

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

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

  251. 

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

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

  254. 

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

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

  257. 

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

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

  260.     else

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

  262. 

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

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

  265. 

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

  267. 

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

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

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

  271. 

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

  273.     {

  274.         char strBuf[STR_MAX+1];

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

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

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

  278.     }

  279.     else

  280.     {

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

  282.     }

  283. 

  284. # ifndef CARLA_OS_WIN

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

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

  287. 

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

  289. 

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

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

  292. 

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

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

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

  296. # endif

  297. #endif

  298. }

  299. 

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

  301. {

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

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

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

  305. 

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

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

  308. 

  309. #ifdef CARLA_OS_WIN

  310.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  311. #endif

  312. 

  313. #ifdef USING_JUCE

  314.     carla_juce_init();

  315. #endif

  316. 

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

  318. 

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

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

  321. 

  322.     shandle.engine = engine;

  323. 

  324. #ifdef BUILD_BRIDGE

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

  326.     {

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

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

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

  330. 

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

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

  333.     }

  334.     else

  335.     {

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

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

  338.     }

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

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

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

  342. #else

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

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

  345. #endif

  346. 

  347.     carla_engine_init_common(shandle, engine);

  348. 

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

  350.     {

  351. #ifndef BUILD_BRIDGE

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

  353.             shandle.logThread.init();

  354. #endif

  355.         shandle.lastError = "No error";

  356.         return true;

  357.     }

  358.     else

  359.     {

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

  361.         shandle.engine = nullptr;

  362.         delete engine;

  363. #ifdef USING_JUCE

  364.         carla_juce_cleanup();

  365. #endif

  366.         return false;

  367.     }

  368. }

  369. 

  370. #ifdef BUILD_BRIDGE

  371. bool carla_engine_init_bridge(CarlaHostHandle handle,

  372.                               const char audioBaseName[6+1],

  373.                               const char rtClientBaseName[6+1],

  374.                               const char nonRtClientBaseName[6+1],

  375.                               const char nonRtServerBaseName[6+1],

  376.                               const char* const clientName)

  377. {

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

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

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

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

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

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

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

  385. 

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

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

  388. 

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

  390.                                                                      rtClientBaseName,

  391.                                                                      nonRtClientBaseName,

  392.                                                                      nonRtServerBaseName));

  393. 

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

  395. 

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

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

  398. 

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

  400. 

  401.     carla_engine_init_common(shandle, engine);

  402. 

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

  404.     {

  405.         shandle.lastError = "No error";

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

  407.         return true;

  408.     }

  409.     else

  410.     {

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

  412.         return false;

  413.     }

  414. }

  415. #endif

  416. 

  417. bool carla_engine_close(CarlaHostHandle handle)

  418. {

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

  420. 

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

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

  423. 

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

  425. 

  426.     CarlaEngine* const engine = shandle.engine;

  427. 

  428.     engine->setAboutToClose();

  429.     engine->removeAllPlugins();

  430. 

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

  432. 

  433.     if (! closed)

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

  435. 

  436. #ifndef BUILD_BRIDGE

  437.     shandle.logThread.stop();

  438. #endif

  439. 

  440.     shandle.engine = nullptr;

  441.     delete engine;

  442. 

  443. #ifdef USING_JUCE

  444.     carla_juce_cleanup();

  445. #endif

  446.     return closed;

  447. }

  448. 

  449. void carla_engine_idle(CarlaHostHandle handle)

  450. {

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

  452. 

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

  454. 

  455. #ifdef USING_JUCE

  456.     if (handle->isStandalone)

  457.         carla_juce_idle();

  458. #endif

  459. }

  460. 

  461. bool carla_is_engine_running(CarlaHostHandle handle)

  462. {

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

  464. }

  465. 

  466. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  467. {

  468.     static CarlaRuntimeEngineInfo retInfo;

  469. 

  470.     // reset

  471.     retInfo.load = 0.0f;

  472.     retInfo.xruns = 0;

  473. 

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

  475. 

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

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

  478. 

  479.     return &retInfo;

  480. }

  481. 

  482. #ifndef BUILD_BRIDGE

  483. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  484. {

  485.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  486. 

  487.     // reset

  488.     retInfo.name = gNullCharPtr;

  489.     retInfo.hints = 0x0;

  490.     retInfo.bufferSize = 0;

  491.     retInfo.bufferSizes = nullptr;

  492.     retInfo.sampleRate = 0.0;

  493.     retInfo.sampleRates = nullptr;

  494. 

  495.     const char* audioDriver;

  496.     const char* audioDevice;

  497. 

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

  499.     {

  500.         audioDriver = engine->getCurrentDriverName();

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

  502. 

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

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

  505.     }

  506.     else if (handle->isStandalone)

  507.     {

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

  509. 

  510.         audioDriver = shandle.engineOptions.audioDriver;

  511.         audioDevice = shandle.engineOptions.audioDevice;

  512. 

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

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

  515.     }

  516.     else

  517.     {

  518.         return &retInfo;

  519.     }

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

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

  522. 

  523.     uint index = 0;

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

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

  526.     {

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

  528.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  529. 

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

  531.             break;

  532.     }

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

  534. 

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

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

  537. 

  538.     retInfo.name        = audioDevice;

  539.     retInfo.hints       = devInfo->hints;

  540.     retInfo.bufferSizes = devInfo->bufferSizes;

  541.     retInfo.sampleRates = devInfo->sampleRates;

  542. 

  543.     return &retInfo;

  544. }

  545. 

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

  547. {

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

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

  550. 

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

  552. }

  553. 

  554. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  555. {

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

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

  558. 

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

  560. }

  561. #endif // BUILD_BRIDGE

  562. 

  563. void carla_clear_engine_xruns(CarlaHostHandle handle)

  564. {

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

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

  567. }

  568. 

  569. void carla_cancel_engine_action(CarlaHostHandle handle)

  570. {

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

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

  573. }

  574. 

  575. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  576. {

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

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

  579. 

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

  581. }

  582. 

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

  584. {

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

  586. 

  587. #ifndef BUILD_BRIDGE

  588.     if (handle->isStandalone)

  589.     {

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

  591. 

  592.         shandle.engineCallback    = func;

  593.         shandle.engineCallbackPtr = ptr;

  594. 

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

  596.     }

  597. #endif

  598. 

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

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

  601. }

  602. 

  603. #ifndef BUILD_BRIDGE

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

  605. {

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

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

  608. 

  609.     if (handle->isStandalone)

  610.     {

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

  612. 

  613.         switch (option)

  614.         {

  615.         case CB::ENGINE_OPTION_DEBUG:

  616.             break;

  617. 

  618.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  621.             break;

  622. 

  623.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  625. 

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

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

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

  629.             {

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

  631. 

  632.                 if (shandle.engineCallback != nullptr)

  633.                     shandle.engineCallback(shandle.engineCallbackPtr,

  634.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  635.                                            0,

  636.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  637.                                            0, 0, 0.0f,

  638.                                            shandle.engineOptions.transportExtra);

  639.             }

  640.             else

  641.             {

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

  643.             }

  644. 

  645.             delete[] shandle.engineOptions.transportExtra;

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

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

  648.             else

  649.                 shandle.engineOptions.transportExtra = nullptr;

  650.             break;

  651. 

  652.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  655.             break;

  656. 

  657.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  660.             break;

  661. 

  662.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  665.             break;

  666. 

  667.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  670.             break;

  671. 

  672.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  673.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  675.             break;

  676. 

  677.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  680.             break;

  681. 

  682.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  683.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  685.             break;

  686. 

  687.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  688.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  690.             break;

  691. 

  692.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  693.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  695.             break;

  696. 

  697.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  700.             break;

  701. 

  702.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  703.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  704. 

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

  706.                 delete[] shandle.engineOptions.audioDriver;

  707. 

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

  709.             break;

  710. 

  711.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  712.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  713. 

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

  715.                 delete[] shandle.engineOptions.audioDevice;

  716. 

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

  718.             break;

  719. 

  720.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  723.             break;

  724. 

  725.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  727.             shandle.engineOptions.oscPortTCP = value;

  728.             break;

  729. 

  730.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  732.             shandle.engineOptions.oscPortUDP = value;

  733.             break;

  734. 

  735.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  738.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  739. 

  740.             switch (value)

  741.             {

  742.             case CB::FILE_AUDIO:

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

  744.                     delete[] shandle.engineOptions.pathAudio;

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

  746.                 break;

  747.             case CB::FILE_MIDI:

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

  749.                     delete[] shandle.engineOptions.pathMIDI;

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

  751.                 break;

  752.             }

  753.             break;

  754. 

  755.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  758.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  759. 

  760.             switch (value)

  761.             {

  762.             case CB::PLUGIN_LADSPA:

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

  764.                     delete[] shandle.engineOptions.pathLADSPA;

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

  766.                 break;

  767.             case CB::PLUGIN_DSSI:

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

  769.                     delete[] shandle.engineOptions.pathDSSI;

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

  771.                 break;

  772.             case CB::PLUGIN_LV2:

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

  774.                     delete[] shandle.engineOptions.pathLV2;

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

  776.                 break;

  777.             case CB::PLUGIN_VST2:

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

  779.                     delete[] shandle.engineOptions.pathVST2;

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

  781.                 break;

  782.             case CB::PLUGIN_VST3:

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

  784.                     delete[] shandle.engineOptions.pathVST3;

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

  786.                 break;

  787.             case CB::PLUGIN_SF2:

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

  789.                     delete[] shandle.engineOptions.pathSF2;

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

  791.                 break;

  792.             case CB::PLUGIN_SFZ:

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

  794.                     delete[] shandle.engineOptions.pathSFZ;

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

  796.                 break;

  797.             }

  798.             break;

  799. 

  800.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  802. 

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

  804.                 delete[] shandle.engineOptions.binaryDir;

  805. 

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

  807.             break;

  808. 

  809.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  811. 

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

  813.                 delete[] shandle.engineOptions.resourceDir;

  814. 

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

  816.             break;

  817. 

  818.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  821.             break;

  822. 

  823.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  825.             break;

  826. 

  827.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  829.             break;

  830. 

  831.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  832.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  834.             break;

  835. 

  836.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  839.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  841.         }   break;

  842. 

  843. # ifndef CARLA_OS_WIN

  844.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  846. 

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

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

  849. 

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

  851.             break;

  852. 

  853.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  856.             break;

  857. 

  858.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  860. 

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

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

  863. 

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

  865.             break;

  866. 

  867.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  870.             break;

  871. 

  872.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  875.             break;

  876. 

  877.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  880.             break;

  881. # endif // CARLA_OS_WIN

  882. 

  883.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  885.             break;

  886.         }

  887.     }

  888. 

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

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

  891. }

  892. #endif // BUILD_BRIDGE

  893. 

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

  895. {

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

  897. 

  898.     if (handle->isStandalone)

  899.     {

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

  901. 

  902.         shandle.fileCallback    = func;

  903.         shandle.fileCallbackPtr = ptr;

  904.     }

  905. 

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

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

  908. }

  909. 

  910. // --------------------------------------------------------------------------------------------------------------------

  911. 

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

  913. {

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

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

  916. 

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

  918. 

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

  920. }

  921. 

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

  923. {

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

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

  926. 

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

  928. 

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

  930. }

  931. 

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

  933. {

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

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

  936. 

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

  938. 

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

  940. }

  941. 

  942. #ifndef BUILD_BRIDGE

  943. void carla_clear_project_filename(CarlaHostHandle handle)

  944. {

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

  946. 

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

  948. 

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

  950. }

  951. 

  952. // --------------------------------------------------------------------------------------------------------------------

  953. 

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

  955. {

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

  957. 

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

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

  960. 

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

  962. }

  963. 

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

  965. {

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

  967. 

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

  969. 

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

  971. }

  972. 

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

  974. {

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

  976. 

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

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

  979. 

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

  981. }

  982. 

  983. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  984. {

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

  986. 

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

  988. 

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

  990. }

  991. 

  992. // --------------------------------------------------------------------------------------------------------------------

  993. 

  994. void carla_transport_play(CarlaHostHandle handle)

  995. {

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

  997. 

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

  999. 

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

  1001. }

  1002. 

  1003. void carla_transport_pause(CarlaHostHandle handle)

  1004. {

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

  1006. 

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

  1008. 

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

  1010. }

  1011. 

  1012. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1013. {

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

  1015. 

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

  1017. 

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

  1019. }

  1020. 

  1021. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1022. {

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

  1024. 

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

  1026. 

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

  1028. }

  1029. 

  1030. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1031. {

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

  1033. 

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

  1035. }

  1036. 

  1037. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1038. {

  1039.     static CarlaTransportInfo retTransInfo;

  1040.     retTransInfo.clear();

  1041. 

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

  1043. 

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

  1045. 

  1046.     retTransInfo.playing = timeInfo.playing;

  1047.     retTransInfo.frame   = timeInfo.frame;

  1048. 

  1049.     if (timeInfo.bbt.valid)

  1050.     {

  1051.         retTransInfo.bar  = timeInfo.bbt.bar;

  1052.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1055.     }

  1056. 

  1057.     return &retTransInfo;

  1058. }

  1059. #endif

  1060. 

  1061. // --------------------------------------------------------------------------------------------------------------------

  1062. 

  1063. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1064. {

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

  1066. 

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

  1068. 

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

  1070. }

  1071. 

  1072. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1073. {

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

  1075. 

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

  1077. 

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

  1079. }

  1080. 

  1081. // --------------------------------------------------------------------------------------------------------------------

  1082. 

  1083. bool carla_add_plugin(CarlaHostHandle handle,

  1084.                       BinaryType btype, PluginType ptype,

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

  1086.                       const void* extraPtr, uint options)

  1087. {

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

  1089. 

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

  1091.                 handle,

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

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

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

  1095. 

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

  1097. }

  1098. 

  1099. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1100. {

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

  1102. 

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

  1104. 

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

  1106. }

  1107. 

  1108. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1109. {

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

  1111. 

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

  1113. 

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

  1115. }

  1116. 

  1117. #ifndef BUILD_BRIDGE

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

  1119. {

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

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

  1122. 

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

  1124. 

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

  1126. }

  1127. 

  1128. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1129. {

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

  1131. 

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

  1133. 

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

  1135. }

  1136. 

  1137. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1138. {

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

  1140. 

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

  1142. 

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

  1144. }

  1145. 

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

  1147. {

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

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

  1150. 

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

  1152. 

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

  1154. }

  1155. #endif

  1156. 

  1157. // --------------------------------------------------------------------------------------------------------------------

  1158. 

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

  1160. {

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

  1162.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1164. 

  1165.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1166.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(plugin != nullptr, "could not find requested plugin", false);

  1167. 

  1168.     carla_debug("carla_load_plugin_state(%p, %i, \"%s\")", handle, pluginId, filename);

  1169. 

  1170.     return plugin->loadStateFromFile(filename);

  1171. }

  1172. 

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

  1174. {

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

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

  1177. 

  1178.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1179.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(plugin != nullptr, "could not find requested plugin", false);

  1180. 

  1181.     carla_debug("carla_save_plugin_state(%p, %i, \"%s\")", handle, pluginId, filename);

  1182. 

  1183.     return plugin->saveStateToFile(filename);

  1184. }

  1185. 

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

  1187. {

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

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

  1190. 

  1191.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1192.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(plugin != nullptr, "could not find requested plugin", false);

  1193. 

  1194.     carla_debug("carla_export_plugin_lv2(%p, %i, \"%s\")", handle, pluginId, lv2path);

  1195. 

  1196.     return plugin->exportAsLV2(lv2path);

  1197. }

  1198. 

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

  1200. 

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

  1202. {

  1203.     static CarlaPluginInfo retInfo;

  1204. 

  1205.     // reset

  1206.     retInfo.type             = CB::PLUGIN_NONE;

  1207.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1208.     retInfo.hints            = 0x0;

  1209.     retInfo.optionsAvailable = 0x0;

  1210.     retInfo.optionsEnabled   = 0x0;

  1211.     retInfo.filename         = gNullCharPtr;

  1212.     retInfo.name             = gNullCharPtr;

  1213.     retInfo.iconName         = gNullCharPtr;

  1214.     retInfo.uniqueId         = 0;

  1215. 

  1216.     // cleanup

  1217.     if (retInfo.label != gNullCharPtr)

  1218.     {

  1219.         delete[] retInfo.label;

  1220.         retInfo.label = gNullCharPtr;

  1221.     }

  1222. 

  1223.     if (retInfo.maker != gNullCharPtr)

  1224.     {

  1225.         delete[] retInfo.maker;

  1226.         retInfo.maker = gNullCharPtr;

  1227.     }

  1228. 

  1229.     if (retInfo.copyright != gNullCharPtr)

  1230.     {

  1231.         delete[] retInfo.copyright;

  1232.         retInfo.copyright = gNullCharPtr;

  1233.     }

  1234. 

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

  1236. 

  1237.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1238.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1239. 

  1240.     carla_debug("carla_get_plugin_info(%p, %i)", handle, pluginId);

  1241. 

  1242.     char strBuf[STR_MAX+1];

  1243.     carla_zeroChars(strBuf, STR_MAX+1);

  1244. 

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

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

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

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

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

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

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

  1252. 

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

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

  1255. 

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

  1257.         retInfo.label = carla_strdup_safe(strBuf);

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

  1259.         retInfo.maker = carla_strdup_safe(strBuf);

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

  1261.         retInfo.copyright = carla_strdup_safe(strBuf);

  1262. 

  1263.     checkStringPtr(retInfo.filename);

  1264.     checkStringPtr(retInfo.name);

  1265.     checkStringPtr(retInfo.iconName);

  1266.     checkStringPtr(retInfo.label);

  1267.     checkStringPtr(retInfo.maker);

  1268.     checkStringPtr(retInfo.copyright);

  1269. 

  1270.     return &retInfo;

  1271. }

  1272. 

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

  1274. {

  1275.     static CarlaPortCountInfo retInfo;

  1276.     carla_zeroStruct(retInfo);

  1277. 

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

  1279. 

  1280.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1281.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1282. 

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

  1284. 

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

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

  1287.     return &retInfo;

  1288. }

  1289. 

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

  1291. {

  1292.     static CarlaPortCountInfo retInfo;

  1293.     carla_zeroStruct(retInfo);

  1294. 

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

  1296. 

  1297.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1298.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1299. 

  1300.     carla_debug("carla_get_midi_port_count_info(%p, %i)", handle, pluginId);

  1301. 

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

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

  1304.     return &retInfo;

  1305. }

  1306. 

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

  1308. {

  1309.     static CarlaPortCountInfo retInfo;

  1310.     carla_zeroStruct(retInfo);

  1311. 

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

  1313. 

  1314.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1315.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1316. 

  1317.     carla_debug("carla_get_parameter_count_info(%p, %i)", handle, pluginId);

  1318. 

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

  1320.     return &retInfo;

  1321. }

  1322. 

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

  1324. {

  1325.     static CarlaParameterInfo retInfo(gNullCharPtr);

  1326. 

  1327.     // reset

  1328.     retInfo.scalePointCount = 0;

  1329. 

  1330.     // cleanup

  1331.     if (retInfo.name != gNullCharPtr)

  1332.     {

  1333.         delete[] retInfo.name;

  1334.         retInfo.name = gNullCharPtr;

  1335.     }

  1336. 

  1337.     if (retInfo.symbol != gNullCharPtr)

  1338.     {

  1339.         delete[] retInfo.symbol;

  1340.         retInfo.symbol = gNullCharPtr;

  1341.     }

  1342. 

  1343.     if (retInfo.unit != gNullCharPtr)

  1344.     {

  1345.         delete[] retInfo.unit;

  1346.         retInfo.unit = gNullCharPtr;

  1347.     }

  1348. 

  1349.     if (retInfo.comment != gNullCharPtr)

  1350.     {

  1351.         delete[] retInfo.comment;

  1352.         retInfo.comment = gNullCharPtr;

  1353.     }

  1354. 

  1355.     if (retInfo.groupName != gNullCharPtr)

  1356.     {

  1357.         delete[] retInfo.groupName;

  1358.         retInfo.groupName = gNullCharPtr;

  1359.     }

  1360. 

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

  1362. 

  1363.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1364.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1365. 

  1366.     carla_debug("carla_get_parameter_info(%p, %i, %i)", handle, pluginId, parameterId);

  1367. 

  1368.     char strBuf[STR_MAX+1];

  1369.     carla_zeroChars(strBuf, STR_MAX+1);

  1370. 

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

  1372. 

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

  1374.     {

  1375.         retInfo.name = carla_strdup_safe(strBuf);

  1376.         carla_zeroChars(strBuf, STR_MAX+1);

  1377.     }

  1378. 

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

  1380.     {

  1381.         retInfo.symbol = carla_strdup_safe(strBuf);

  1382.         carla_zeroChars(strBuf, STR_MAX+1);

  1383.     }

  1384. 

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

  1386.     {

  1387.         retInfo.unit = carla_strdup_safe(strBuf);

  1388.         carla_zeroChars(strBuf, STR_MAX+1);

  1389.     }

  1390. 

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

  1392.     {

  1393.         retInfo.comment = carla_strdup_safe(strBuf);

  1394.         carla_zeroChars(strBuf, STR_MAX+1);

  1395.     }

  1396. 

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

  1398.     {

  1399.         retInfo.groupName = carla_strdup_safe(strBuf);

  1400.         carla_zeroChars(strBuf, STR_MAX+1);

  1401.     }

  1402. 

  1403.     checkStringPtr(retInfo.name);

  1404.     checkStringPtr(retInfo.symbol);

  1405.     checkStringPtr(retInfo.unit);

  1406.     checkStringPtr(retInfo.comment);

  1407.     checkStringPtr(retInfo.groupName);

  1408. 

  1409.     return &retInfo;

  1410. }

  1411. 

  1412. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1413.                                                                uint pluginId,

  1414.                                                                uint32_t parameterId,

  1415.                                                                uint32_t scalePointId)

  1416. {

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

  1418. 

  1419.     static CarlaScalePointInfo retInfo;

  1420. 

  1421.     // reset

  1422.     retInfo.value = 0.0f;

  1423. 

  1424.     // cleanup

  1425.     if (retInfo.label != gNullCharPtr)

  1426.     {

  1427.         delete[] retInfo.label;

  1428.         retInfo.label = gNullCharPtr;

  1429.     }

  1430. 

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

  1432. 

  1433.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1434.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retInfo);

  1435. 

  1436.     carla_debug("carla_get_parameter_scalepoint_info(%p, %i, %i, %i)", handle, pluginId, parameterId, scalePointId);

  1437. 

  1438.     char strBuf[STR_MAX+1];

  1439. 

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

  1441. 

  1442.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1444.         retInfo.label = carla_strdup_safe(strBuf);

  1445. 

  1446.     checkStringPtr(retInfo.label);

  1447. 

  1448.     return &retInfo;

  1449. }

  1450. 

  1451. // --------------------------------------------------------------------------------------------------------------------

  1452. 

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

  1454. {

  1455.     static ParameterData retParamData;

  1456. 

  1457.     // reset

  1458.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1459.     retParamData.hints       = 0x0;

  1460.     retParamData.index       = CB::PARAMETER_NULL;

  1461.     retParamData.rindex      = -1;

  1462.     retParamData.midiChannel = 0;

  1463.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1464.     retParamData.mappedMinimum = 0.0f;

  1465.     retParamData.mappedMaximum = 0.0f;

  1466. 

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

  1468. 

  1469.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1470.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retParamData);

  1471. 

  1472.     carla_debug("carla_get_parameter_data(%p, %i, %i)", handle, pluginId, parameterId);

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

  1474. 

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

  1476.     retParamData.type        = pluginParamData.type;

  1477.     retParamData.hints       = pluginParamData.hints;

  1478.     retParamData.index       = pluginParamData.index;

  1479.     retParamData.rindex      = pluginParamData.rindex;

  1480.     retParamData.midiChannel = pluginParamData.midiChannel;

  1481.     retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1482.     retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1483.     retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1484.     return &plugin->getParameterData(parameterId);

  1485. }

  1486. 

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

  1488. {

  1489.     static ParameterRanges retParamRanges;

  1490. 

  1491.     // reset

  1492.     retParamRanges.def       = 0.0f;

  1493.     retParamRanges.min       = 0.0f;

  1494.     retParamRanges.max       = 1.0f;

  1495.     retParamRanges.step      = 0.01f;

  1496.     retParamRanges.stepSmall = 0.0001f;

  1497.     retParamRanges.stepLarge = 0.1f;

  1498. 

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

  1500. 

  1501.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1502.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retParamRanges);

  1503. 

  1504.     carla_debug("carla_get_parameter_ranges(%p, %i, %i)", handle, pluginId, parameterId);

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

  1506. 

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

  1508.     retParamRanges.def       = pluginParamRanges.def;

  1509.     retParamRanges.min       = pluginParamRanges.min;

  1510.     retParamRanges.max       = pluginParamRanges.max;

  1511.     retParamRanges.step      = pluginParamRanges.step;

  1512.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1513.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1514.     return &pluginParamRanges;

  1515. }

  1516. 

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

  1518. {

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

  1520. 

  1521.     // reset

  1522.     retMidiProgData.bank    = 0;

  1523.     retMidiProgData.program = 0;

  1524. 

  1525.     if (retMidiProgData.name != gNullCharPtr)

  1526.     {

  1527.         delete[] retMidiProgData.name;

  1528.         retMidiProgData.name = gNullCharPtr;

  1529.     }

  1530. 

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

  1532. 

  1533.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1534.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retMidiProgData);

  1535. 

  1536.     carla_debug("carla_get_midi_program_data(%p, %i, %i)", handle, pluginId, midiProgramId);

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

  1538. 

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

  1540.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1541.     retMidiProgData.program = pluginMidiProgData.program;

  1542. 

  1543.     if (pluginMidiProgData.name != nullptr)

  1544.     {

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

  1546.         checkStringPtr(retMidiProgData.name);

  1547.     }

  1548.     else

  1549.     {

  1550.         retMidiProgData.name = gNullCharPtr;

  1551.     }

  1552. 

  1553.     return &retMidiProgData;

  1554. }

  1555. 

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

  1557. {

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

  1559. 

  1560.     // reset

  1561.     if (retCustomData.type != gNullCharPtr)

  1562.     {

  1563.         delete[] retCustomData.type;

  1564.         retCustomData.type = gNullCharPtr;

  1565.     }

  1566. 

  1567.     if (retCustomData.key != gNullCharPtr)

  1568.     {

  1569.         delete[] retCustomData.key;

  1570.         retCustomData.key = gNullCharPtr;

  1571.     }

  1572. 

  1573.     if (retCustomData.value != gNullCharPtr)

  1574.     {

  1575.         delete[] retCustomData.value;

  1576.         retCustomData.value = gNullCharPtr;

  1577.     }

  1578. 

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

  1580. 

  1581.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1582.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, &retCustomData);

  1583. 

  1584.     carla_debug("carla_get_custom_data(%p, %i, %i)", handle, pluginId, customDataId);

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

  1586. 

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

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

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

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

  1591.     checkStringPtr(retCustomData.type);

  1592.     checkStringPtr(retCustomData.key);

  1593.     checkStringPtr(retCustomData.value);

  1594.     return &retCustomData;

  1595. }

  1596. 

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

  1598. {

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

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

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

  1602. 

  1603.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1604.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1605. 

  1606.     carla_debug("carla_get_custom_data_value(%p, %i, %s, %s)", handle, pluginId, type, key);

  1607. 

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

  1609. 

  1610.     if (count == 0)

  1611.         return gNullCharPtr;

  1612. 

  1613.     static CarlaString customDataValue;

  1614. 

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

  1616.     {

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

  1618. 

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

  1620.             continue;

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

  1622.             continue;

  1623. 

  1624.         customDataValue = pluginCustomData.value;

  1625.         return customDataValue.buffer();

  1626.     }

  1627. 

  1628.     return gNullCharPtr;

  1629. }

  1630. 

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

  1632. {

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

  1634. 

  1635.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1636.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1637. 

  1638.     carla_debug("carla_get_chunk_data(%p, %i)", handle, pluginId);

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

  1640. 

  1641.     void* data = nullptr;

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

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

  1644. 

  1645.     static CarlaString chunkData;

  1646. 

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

  1648.     return chunkData.buffer();

  1649. }

  1650. 

  1651. // --------------------------------------------------------------------------------------------------------------------

  1652. 

  1653. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1654. {

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

  1656. 

  1657.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1658.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1659. 

  1660.     carla_debug("carla_get_parameter_count(%p, %i)", handle, pluginId);

  1661.     return plugin->getParameterCount();

  1662. }

  1663. 

  1664. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1665. {

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

  1667. 

  1668.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1669.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1670. 

  1671.     carla_debug("carla_get_program_count(%p, %i)", handle, pluginId);

  1672.     return plugin->getProgramCount();

  1673. }

  1674. 

  1675. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1676. {

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

  1678. 

  1679.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1680.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1681. 

  1682.     carla_debug("carla_get_midi_program_count(%p, %i)", handle, pluginId);

  1683.     return plugin->getMidiProgramCount();

  1684. }

  1685. 

  1686. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1687. {

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

  1689. 

  1690.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1691.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0);

  1692. 

  1693.     carla_debug("carla_get_custom_data_count(%p, %i)", handle, pluginId);

  1694.     return plugin->getCustomDataCount();

  1695. }

  1696. 

  1697. // --------------------------------------------------------------------------------------------------------------------

  1698. 

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

  1700. {

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

  1702. 

  1703.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1704.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1705. 

  1706.     carla_debug("carla_get_parameter_text(%p, %i, %i)", handle, pluginId, parameterId);

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

  1708. 

  1709.     static char textBuf[STR_MAX+1];

  1710.     carla_zeroChars(textBuf, STR_MAX+1);

  1711. 

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

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

  1714. 

  1715.     return textBuf;

  1716. }

  1717. 

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

  1719. {

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

  1721. 

  1722.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1723.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1724. 

  1725.     carla_debug("carla_get_program_name(%p, %i, %i)", handle, pluginId, programId);

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

  1727. 

  1728.     static char programName[STR_MAX+1];

  1729.     carla_zeroChars(programName, STR_MAX+1);

  1730. 

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

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

  1733. 

  1734.     return programName;

  1735. }

  1736. 

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

  1738. {

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

  1740. 

  1741.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1742.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1743. 

  1744.     carla_debug("carla_get_midi_program_name(%p, %i, %i)", handle, pluginId, midiProgramId);

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

  1746. 

  1747.     static char midiProgramName[STR_MAX+1];

  1748.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1749. 

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

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

  1752. 

  1753.     return midiProgramName;

  1754. }

  1755. 

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

  1757. {

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

  1759. 

  1760.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1761.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, gNullCharPtr);

  1762. 

  1763.     carla_debug("carla_get_real_plugin_name(%p, %i)", handle, pluginId);

  1764.     static char realPluginName[STR_MAX+1];

  1765.     carla_zeroChars(realPluginName, STR_MAX+1);

  1766. 

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

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

  1769. 

  1770.     return realPluginName;

  1771. }

  1772. 

  1773. // --------------------------------------------------------------------------------------------------------------------

  1774. 

  1775. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1776. {

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

  1778. 

  1779.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1780.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, -1);

  1781. 

  1782.     carla_debug("carla_get_current_program_index(%p, %i)", handle, pluginId);

  1783.     return plugin->getCurrentProgram();

  1784. }

  1785. 

  1786. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1787. {

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

  1789. 

  1790.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1791.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, -1);

  1792. 

  1793.     carla_debug("carla_get_current_midi_program_index(%p, %i)", handle, pluginId);

  1794.     return plugin->getCurrentMidiProgram();

  1795. }

  1796. 

  1797. // --------------------------------------------------------------------------------------------------------------------

  1798. 

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

  1800. {

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

  1802. 

  1803.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1804.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0.0f);

  1805. 

  1806.     carla_debug("carla_get_default_parameter_value(%p, %i, %i)", handle, pluginId, parameterId);

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

  1808. 

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

  1810. }

  1811. 

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

  1813. {

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

  1815. 

  1816.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1817.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0.0f);

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

  1819. 

  1820.     return plugin->getParameterValue(parameterId);

  1821. }

  1822. 

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

  1824. {

  1825. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1827. #else

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

  1829. #endif

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

  1831. 

  1832.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1833.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, 0.0f);

  1834. 

  1835.     carla_debug("carla_get_internal_parameter_value(%p, %i, %i)", handle, pluginId, parameterId);

  1836.     return plugin->getInternalParameterValue(parameterId);

  1837. }

  1838. 

  1839. // --------------------------------------------------------------------------------------------------------------------

  1840. 

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

  1842. {

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

  1844. 

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

  1846. }

  1847. 

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

  1849. {

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

  1851. 

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

  1853. }

  1854. 

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

  1856. {

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

  1858. 

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

  1860. }

  1861. 

  1862. // --------------------------------------------------------------------------------------------------------------------

  1863. 

  1864. CARLA_BACKEND_START_NAMESPACE

  1865. 

  1866. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1867. // defined in CarlaPluginInternal.cpp

  1868. const void* carla_render_inline_display_internal(CarlaPlugin* plugin, uint32_t  width, uint32_t height);

  1869. #endif

  1870. 

  1871. // defined in CarlaPluginLV2.cpp

  1872. const void* carla_render_inline_display_lv2(CarlaPlugin* plugin, uint32_t width, uint32_t height);

  1873. 

  1874. CARLA_BACKEND_END_NAMESPACE

  1875. 

  1876. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  1877.                                                                   uint pluginId,

  1878.                                                                   uint32_t width, uint32_t height)

  1879. {

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

  1881. 

  1882.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1883.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr, nullptr);

  1884. 

  1885.     carla_debug("carla_render_inline_display(%p, %i, %i, %i)", handle, pluginId, width, height);

  1886. 

  1887.     switch (plugin->getType())

  1888.     {

  1889. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1890.     case CB::PLUGIN_INTERNAL:

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

  1892. #endif

  1893.     case CB::PLUGIN_LV2:

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

  1895.     default:

  1896.         return nullptr;

  1897.     }

  1898. }

  1899. 

  1900. // --------------------------------------------------------------------------------------------------------------------

  1901. 

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

  1903. {

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

  1905. 

  1906.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1907.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1908. 

  1909.     carla_debug("carla_set_active(%p, %i, %s)", handle, pluginId, bool2str(onOff));

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

  1911. }

  1912. 

  1913. #ifndef BUILD_BRIDGE

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

  1915. {

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

  1917. 

  1918.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1919.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1920. 

  1921.     carla_debug("carla_set_drywet(%p, %i, %f)", handle, pluginId, static_cast<double>(value));

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

  1923. }

  1924. 

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

  1926. {

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

  1928. 

  1929.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1930.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1931. 

  1932.     carla_debug("carla_set_volume(%p, %i, %f)", handle, pluginId, static_cast<double>(value));

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

  1934. }

  1935. 

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

  1937. {

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

  1939. 

  1940.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1941.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1942. 

  1943.     carla_debug("carla_set_balance_left(%p, %i, %f)", handle, pluginId, static_cast<double>(value));

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

  1945. }

  1946. 

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

  1948. {

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

  1950. 

  1951.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1952.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1953. 

  1954.     carla_debug("carla_set_balance_right(%p, %i, %f)", handle, pluginId, static_cast<double>(value));

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

  1956. }

  1957. 

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

  1959. {

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

  1961. 

  1962.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1963.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1964. 

  1965.     carla_debug("carla_set_panning(%p, %i, %f)", handle, pluginId, static_cast<double>(value));

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

  1967. }

  1968. 

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

  1970. {

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

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

  1973. 

  1974.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1975.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1976. 

  1977.     carla_debug("carla_set_ctrl_channel(%p, %i, %i)", handle, pluginId, channel);

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

  1979. }

  1980. #endif

  1981. 

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

  1983. {

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

  1985. 

  1986.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  1987.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1988. 

  1989.     carla_debug("carla_set_option(%p, %i, %i, %s)", handle, pluginId, option, bool2str(yesNo));

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

  1991. }

  1992. 

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

  1994. 

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

  1996. {

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

  1998. 

  1999.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2000.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2001. 

  2002.     carla_debug("carla_set_parameter_value(%p, %i, %i, %f)", handle, pluginId, parameterId, static_cast<double>(value));

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

  2004. 

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

  2006. }

  2007. 

  2008. #ifndef BUILD_BRIDGE

  2009. 

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

  2011. {

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

  2013.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2014. 

  2015.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2016.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2017. 

  2018.     carla_debug("carla_set_parameter_midi_channel(%p, %i, %i, %i)", handle, pluginId, parameterId, channel);

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

  2020. 

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

  2022. }

  2023. 

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

  2025. {

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

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

  2028. 

  2029.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2030.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2031. 

  2032.     carla_debug("carla_set_parameter_mapped_control_index(%p, %i, %i, %i)", handle, pluginId, parameterId, index);

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

  2034. 

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

  2036. }

  2037. 

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

  2039. {

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

  2041. 

  2042.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2043.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2044. 

  2045.     carla_debug("carla_set_parameter_mapped_range(%p, %i, %i, %f, %f)",

  2046.                 handle, pluginId, parameterId, static_cast<double>(minimum), static_cast<double>(maximum));

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

  2048. 

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

  2050. }

  2051. 

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

  2053. {

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

  2055. 

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

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

  2058. }

  2059. #endif

  2060. 

  2061. // --------------------------------------------------------------------------------------------------------------------

  2062. 

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

  2064. {

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

  2066. 

  2067.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2068.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2069. 

  2070.     carla_debug("carla_set_program(%p, %i, %i)", handle, pluginId, programId);

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

  2072. 

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

  2074. }

  2075. 

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

  2077. {

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

  2079. 

  2080.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2081.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2082. 

  2083.     carla_debug("carla_set_midi_program(%p, %i, %i)", handle, pluginId, midiProgramId);

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

  2085. 

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

  2087. }

  2088. 

  2089. // --------------------------------------------------------------------------------------------------------------------

  2090. 

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

  2092. {

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

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

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

  2096.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2097. 

  2098.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2099.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2100. 

  2101.     carla_debug("carla_set_custom_data(%p, %i, \"%s\", \"%s\", \"%s\")", handle, pluginId, type, key, value);

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

  2103. }

  2104. 

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

  2106. {

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

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

  2109. 

  2110.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2111.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2112. 

  2113.     carla_debug("carla_set_chunk_data(%p, %i, \"%s\")", handle, pluginId, chunkData);

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

  2115. 

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

  2117. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2119. #else

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

  2121. #endif

  2122. }

  2123. 

  2124. // --------------------------------------------------------------------------------------------------------------------

  2125. 

  2126. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2127. {

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

  2129. 

  2130.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2131.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2132. 

  2133.     carla_debug("carla_prepare_for_save(%p, %i)", handle, pluginId);

  2134.     return plugin->prepareForSave();

  2135. }

  2136. 

  2137. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2138. {

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

  2140. 

  2141.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2142.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2143. 

  2144.     carla_debug("carla_reset_parameters(%p, %i)", handle, pluginId);

  2145.     return plugin->resetParameters();

  2146. }

  2147. 

  2148. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2149. {

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

  2151. 

  2152.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2153.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2154. 

  2155.     carla_debug("carla_randomize_parameters(%p, %i)", handle, pluginId);

  2156.     return plugin->randomizeParameters();

  2157. }

  2158. 

  2159. #ifndef BUILD_BRIDGE

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

  2161. {

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

  2163. 

  2164.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2165.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2166. 

  2167.     carla_debug("carla_send_midi_note(%p, %i, %i, %i, %i)", handle, pluginId, channel, note, velocity);

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

  2169. }

  2170. #endif

  2171. 

  2172. void carla_set_custom_ui_title_format(CarlaHostHandle handle, uint pluginId, const char* format)

  2173. {

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

  2175.     CARLA_SAFE_ASSERT_RETURN(format != nullptr && format[0] != '\0',);

  2176. 

  2177.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2178.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2179. 

  2180.     carla_debug("carla_randomize_parameters(%p, %i, %s)", handle, pluginId, format);

  2181.     return plugin->setCustomUiTitleFormat(format);

  2182. }

  2183. 

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

  2185. {

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

  2187. 

  2188.     CarlaPlugin* const plugin = handle->engine->getPlugin(pluginId);

  2189.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2190. 

  2191.     carla_debug("carla_show_custom_ui(%p, %i, %s)", handle, pluginId, bool2str(yesNo));

  2192.     return plugin->showCustomUI(yesNo);

  2193. }

  2194. 

  2195. // --------------------------------------------------------------------------------------------------------------------

  2196. 

  2197. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2198. {

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

  2200. 

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

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

  2203. }

  2204. 

  2205. double carla_get_sample_rate(CarlaHostHandle handle)

  2206. {

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

  2208. 

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

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

  2211. }

  2212. 

  2213. // --------------------------------------------------------------------------------------------------------------------

  2214. 

  2215. const char* carla_get_last_error(CarlaHostHandle handle)

  2216. {

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

  2218. 

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

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

  2221. 

  2222.     return handle->isStandalone

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

  2224.            : gNullCharPtr;

  2225. }

  2226. 

  2227. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2228. {

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

  2230. 

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

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

  2233.     {

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

  2235.         if (handle->isStandalone)

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

  2237.         return gNullCharPtr;

  2238.     }

  2239. 

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

  2241. 

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

  2243.         return path;

  2244. 

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

  2246.     return notAvailable;

  2247. #else

  2248.     return gNullCharPtr;

  2249. 

  2250.     // unused

  2251.     (void)handle;

  2252. #endif

  2253. }

  2254. 

  2255. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2256. {

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

  2258. 

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

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

  2261.     {

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

  2263.         if (handle->isStandalone)

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

  2265.         return gNullCharPtr;

  2266.     }

  2267. 

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

  2269. 

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

  2271.         return path;

  2272. 

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

  2274.     return notAvailable;

  2275. #else

  2276.     return gNullCharPtr;

  2277. 

  2278.     // unused

  2279.     (void)handle;

  2280. #endif

  2281. }

  2282. 

  2283. // --------------------------------------------------------------------------------------------------------------------

  2284. 

  2285. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2286. #include "CarlaPluginUI.cpp"

  2287. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2288. 

  2289. #include "CarlaDssiUtils.cpp"

  2290. #include "CarlaMacUtils.cpp"

  2291. #include "CarlaPatchbayUtils.cpp"

  2292. #include "CarlaPipeUtils.cpp"

  2293. #include "CarlaProcessUtils.cpp"

  2294. #include "CarlaStateUtils.cpp"

  2295. 

  2296. // --------------------------------------------------------------------------------------------------------------------