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

2280 lines
82KB
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 "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngine.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. #ifdef USING_JUCE

  38. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  39. #  pragma GCC diagnostic push

  40. #  pragma GCC diagnostic ignored "-Wconversion"

  41. #  pragma GCC diagnostic ignored "-Weffc++"

  42. #  pragma GCC diagnostic ignored "-Wsign-conversion"

  43. #  pragma GCC diagnostic ignored "-Wundef"

  44. # endif

  45. 

  46. # include "AppConfig.h"

  47. # include "juce_events/juce_events.h"

  48. 

  49. # if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))

  50. #  pragma GCC diagnostic pop

  51. # endif

  52. #endif

  53. 

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

  55.     if (! (cond)) {                                              \

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

  57.         gStandalone.lastError = msg;                             \

  58.         return ret;                                              \

  59.     }

  60. 

  61. namespace CB = CarlaBackend;

  62. using CB::EngineOptions;

  63. 

  64. // --------------------------------------------------------------------------------------------------------------------

  65. // Single, standalone engine

  66. 

  67. struct CarlaBackendStandalone {

  68.     CarlaEngine*       engine;

  69.     EngineCallbackFunc engineCallback;

  70.     void*              engineCallbackPtr;

  71. #ifndef BUILD_BRIDGE

  72.     EngineOptions      engineOptions;

  73.     CarlaLogThread     logThread;

  74.     bool               logThreadEnabled;

  75. #endif

  76. 

  77.     FileCallbackFunc fileCallback;

  78.     void*            fileCallbackPtr;

  79. 

  80.     CarlaString lastError;

  81. 

  82.     CarlaBackendStandalone() noexcept

  83.         : engine(nullptr),

  84.           engineCallback(nullptr),

  85.           engineCallbackPtr(nullptr),

  86. #ifndef BUILD_BRIDGE

  87.           engineOptions(),

  88.           logThread(),

  89.           logThreadEnabled(false),

  90. #endif

  91.           fileCallback(nullptr),

  92.           fileCallbackPtr(nullptr),

  93.           lastError() {}

  94. 

  95.     ~CarlaBackendStandalone() noexcept

  96.     {

  97.         CARLA_SAFE_ASSERT(engine == nullptr);

  98.     }

  99. 

  100.     CARLA_PREVENT_HEAP_ALLOCATION

  101.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  102. };

  103. 

  104. CarlaBackendStandalone gStandalone;

  105. 

  106. #ifdef CARLA_OS_UNIX

  107. static ThreadSafeFFTW sThreadSafeFFTW;

  108. #endif

  109. 

  110. // --------------------------------------------------------------------------------------------------------------------

  111. // API

  112. 

  113. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  114. #include "CarlaHostCommon.cpp"

  115. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  116. 

  117. // --------------------------------------------------------------------------------------------------------------------

  118. 

  119. uint carla_get_engine_driver_count()

  120. {

  121.     carla_debug("carla_get_engine_driver_count()");

  122. 

  123.     return CarlaEngine::getDriverCount();

  124. }

  125. 

  126. const char* carla_get_engine_driver_name(uint index)

  127. {

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

  129. 

  130.     return CarlaEngine::getDriverName(index);

  131. }

  132. 

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

  134. {

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

  136. 

  137.     return CarlaEngine::getDriverDeviceNames(index);

  138. }

  139. 

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

  141. {

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

  143. 

  144.     static EngineDriverDeviceInfo retDevInfo;

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

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

  147. 

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

  149. 

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

  151.     {

  152.         retDevInfo.hints       =  devInfo->hints;

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

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

  155.     }

  156.     else

  157.     {

  158.         retDevInfo.hints       = 0x0;

  159.         retDevInfo.bufferSizes = nullBufferSizes;

  160.         retDevInfo.sampleRates = nullSampleRates;

  161.     }

  162. 

  163.     return &retDevInfo;

  164. }

  165. 

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

  167. {

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

  169. }

  170. 

  171. // --------------------------------------------------------------------------------------------------------------------

  172. 

  173. CarlaEngine* carla_get_engine()

  174. {

  175.     carla_debug("carla_get_engine()");

  176. 

  177.     return gStandalone.engine;

  178. }

  179. 

  180. // --------------------------------------------------------------------------------------------------------------------

  181. 

  182. static void carla_engine_init_common(CarlaEngine* const engine)

  183. {

  184.     engine->setCallback(gStandalone.engineCallback, gStandalone.engineCallbackPtr);

  185.     engine->setFileCallback(gStandalone.fileCallback, gStandalone.fileCallbackPtr);

  186. 

  187.     using water::File;

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

  189. 

  190. #ifdef BUILD_BRIDGE

  191.     /*

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

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

  194. 

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

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

  197. 

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

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

  200.     */

  201. 

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

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

  204. 

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

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

  207. 

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

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

  210. 

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

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

  213. 

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

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

  216. 

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

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

  219. 

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

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

  222. 

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

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

  225. 

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

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

  228. 

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

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

  231. 

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

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

  234. 

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

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

  237. 

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

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

  240. 

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

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

  243.     else

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

  245. 

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

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

  248.     else

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

  250. 

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

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

  253. 

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

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

  256. #else

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

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

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

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

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

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

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

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

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

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

  267. 

  268.     if (gStandalone.engineOptions.audioDriver != nullptr)

  269.         engine->setOption(CB::ENGINE_OPTION_AUDIO_DRIVER,      0, gStandalone.engineOptions.audioDriver);

  270. 

  271.     if (gStandalone.engineOptions.audioDevice != nullptr)

  272.         engine->setOption(CB::ENGINE_OPTION_AUDIO_DEVICE,      0, gStandalone.engineOptions.audioDevice);

  273. 

  274.     engine->setOption(CB::ENGINE_OPTION_OSC_ENABLED,  gStandalone.engineOptions.oscEnabled, nullptr);

  275.     engine->setOption(CB::ENGINE_OPTION_OSC_PORT_TCP, gStandalone.engineOptions.oscPortTCP, nullptr);

  276.     engine->setOption(CB::ENGINE_OPTION_OSC_PORT_UDP, gStandalone.engineOptions.oscPortUDP, nullptr);

  277. 

  278.     if (gStandalone.engineOptions.pathAudio != nullptr)

  279.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_AUDIO, gStandalone.engineOptions.pathAudio);

  280. 

  281.     if (gStandalone.engineOptions.pathMIDI != nullptr)

  282.         engine->setOption(CB::ENGINE_OPTION_FILE_PATH, CB::FILE_MIDI, gStandalone.engineOptions.pathMIDI);

  283. 

  284.     if (gStandalone.engineOptions.pathLADSPA != nullptr)

  285.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LADSPA, gStandalone.engineOptions.pathLADSPA);

  286. 

  287.     if (gStandalone.engineOptions.pathDSSI != nullptr)

  288.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_DSSI, gStandalone.engineOptions.pathDSSI);

  289. 

  290.     if (gStandalone.engineOptions.pathLV2 != nullptr)

  291.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_LV2, gStandalone.engineOptions.pathLV2);

  292. 

  293.     if (gStandalone.engineOptions.pathVST2 != nullptr)

  294.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST2, gStandalone.engineOptions.pathVST2);

  295. 

  296.     if (gStandalone.engineOptions.pathVST3 != nullptr)

  297.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_VST3, gStandalone.engineOptions.pathVST3);

  298. 

  299.     if (gStandalone.engineOptions.pathSF2 != nullptr)

  300.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SF2, gStandalone.engineOptions.pathSF2);

  301. 

  302.     if (gStandalone.engineOptions.pathSFZ != nullptr)

  303.         engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_SFZ, gStandalone.engineOptions.pathSFZ);

  304. 

  305.     if (gStandalone.engineOptions.binaryDir != nullptr && gStandalone.engineOptions.binaryDir[0] != '\0')

  306.         engine->setOption(CB::ENGINE_OPTION_PATH_BINARIES, 0, gStandalone.engineOptions.binaryDir);

  307.     else

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

  309. 

  310.     if (gStandalone.engineOptions.resourceDir != nullptr && gStandalone.engineOptions.resourceDir[0] != '\0')

  311.         engine->setOption(CB::ENGINE_OPTION_PATH_RESOURCES,    0, gStandalone.engineOptions.resourceDir);

  312. 

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

  314. 

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

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

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

  318. 

  319.     if (gStandalone.engineOptions.frontendWinId != 0)

  320.     {

  321.         char strBuf[STR_MAX+1];

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

  323.         std::snprintf(strBuf, STR_MAX, P_UINTPTR, gStandalone.engineOptions.frontendWinId);

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

  325.     }

  326.     else

  327.     {

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

  329.     }

  330. 

  331. # ifndef CARLA_OS_WIN

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

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

  334. 

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

  336. 

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

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

  339. 

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

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

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

  343. # endif

  344. #endif

  345. }

  346. 

  347. bool carla_engine_init(const char* driverName, const char* clientName)

  348. {

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

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

  351.     carla_debug("carla_engine_init(\"%s\", \"%s\")", driverName, clientName);

  352. 

  353.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine == nullptr, "Engine is already initialized", false);

  354. 

  355. #ifdef CARLA_OS_WIN

  356.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  357. #endif

  358. 

  359. #ifdef USING_JUCE

  360.     juce::initialiseJuce_GUI();

  361. #endif

  362. 

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

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

  365. 

  366.     gStandalone.engine = engine;

  367. 

  368. #ifdef BUILD_BRIDGE

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

  370.     {

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

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

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

  374. 

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

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

  377.     }

  378.     else

  379.     {

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

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

  382.     }

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

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

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

  386. #else

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

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

  389. #endif

  390. 

  391.     carla_engine_init_common(engine);

  392. 

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

  394.     {

  395. #ifndef BUILD_BRIDGE

  396.         if (gStandalone.logThreadEnabled && std::getenv("CARLA_LOGS_DISABLED") == nullptr)

  397.             gStandalone.logThread.init();

  398. #endif

  399. #ifdef CARLA_OS_UNIX

  400.         sThreadSafeFFTW.init();

  401. #endif

  402.         gStandalone.lastError = "No error";

  403.         return true;

  404.     }

  405.     else

  406.     {

  407.         gStandalone.lastError = engine->getLastError();

  408.         gStandalone.engine = nullptr;

  409.         delete engine;

  410. #ifdef USING_JUCE

  411.         juce::shutdownJuce_GUI();

  412. #endif

  413.         return false;

  414.     }

  415. }

  416. 

  417. #ifdef BUILD_BRIDGE

  418. bool carla_engine_init_bridge(const char audioBaseName[6+1],

  419.                               const char rtClientBaseName[6+1],

  420.                               const char nonRtClientBaseName[6+1],

  421.                               const char nonRtServerBaseName[6+1],

  422.                               const char* const clientName)

  423. {

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

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

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

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

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

  429.     carla_debug("carla_engine_init_bridge(\"%s\", \"%s\", \"%s\", \"%s\", \"%s\")",

  430.                 audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName, clientName);

  431. 

  432.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine == nullptr, "Engine is already initialized", false);

  433. 

  434.     CarlaScopedPointer<CarlaEngine> engine(CarlaEngine::newBridge(audioBaseName,

  435.                                                                   rtClientBaseName,

  436.                                                                   nonRtClientBaseName,

  437.                                                                   nonRtServerBaseName));

  438. 

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

  440. 

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

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

  443. 

  444.     carla_engine_init_common(engine);

  445. 

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

  447.     {

  448.         gStandalone.lastError = "No error";

  449.         gStandalone.engine = engine.release();

  450.         return true;

  451.     }

  452.     else

  453.     {

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

  455.         return false;

  456.     }

  457. }

  458. #endif

  459. 

  460. bool carla_engine_close()

  461. {

  462.     carla_debug("carla_engine_close()");

  463. 

  464.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  465. 

  466. #ifdef CARLA_OS_UNIX

  467.     const ThreadSafeFFTW::Deinitializer tsfftwde(sThreadSafeFFTW);

  468. #endif

  469. 

  470.     CarlaEngine* const engine = gStandalone.engine;

  471. 

  472.     engine->setAboutToClose();

  473.     engine->removeAllPlugins();

  474. 

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

  476. 

  477.     if (! closed)

  478.         gStandalone.lastError = engine->getLastError();

  479. 

  480. #ifndef BUILD_BRIDGE

  481.     gStandalone.logThread.stop();

  482. #endif

  483. 

  484.     gStandalone.engine = nullptr;

  485.     delete engine;

  486. 

  487. #ifdef USING_JUCE

  488.     juce::shutdownJuce_GUI();

  489. #endif

  490.     return closed;

  491. }

  492. 

  493. void carla_engine_idle()

  494. {

  495.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  496. 

  497.     gStandalone.engine->idle();

  498. 

  499. #if defined(USING_JUCE) && !(defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN))

  500.     const juce::MessageManager* const msgMgr(juce::MessageManager::getInstanceWithoutCreating());

  501.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  502. 

  503.     for (; msgMgr->dispatchNextMessageOnSystemQueue(true);) {}

  504. #endif

  505. }

  506. 

  507. bool carla_is_engine_running()

  508. {

  509.     return (gStandalone.engine != nullptr && gStandalone.engine->isRunning());

  510. }

  511. 

  512. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info()

  513. {

  514.     static CarlaRuntimeEngineInfo retInfo;

  515. 

  516.     // reset

  517.     retInfo.load = 0.0f;

  518.     retInfo.xruns = 0;

  519. 

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

  521. 

  522.     retInfo.load = gStandalone.engine->getDSPLoad();

  523.     retInfo.xruns = gStandalone.engine->getTotalXruns();

  524. 

  525.     return &retInfo;

  526. }

  527. 

  528. #ifndef BUILD_BRIDGE

  529. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info()

  530. {

  531.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  532. 

  533.     // reset

  534.     retInfo.name = gNullCharPtr;

  535.     retInfo.hints = 0x0;

  536.     retInfo.bufferSize = 0;

  537.     retInfo.bufferSizes = nullptr;

  538.     retInfo.sampleRate = 0.0;

  539.     retInfo.sampleRates = nullptr;

  540. 

  541.     const char* audioDriver;

  542.     const char* audioDevice;

  543. 

  544.     if (CarlaEngine* const engine = gStandalone.engine)

  545.     {

  546.         audioDriver = engine->getCurrentDriverName();

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

  548. 

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

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

  551.     }

  552.     else

  553.     {

  554.         audioDriver = gStandalone.engineOptions.audioDriver;

  555.         audioDevice = gStandalone.engineOptions.audioDevice;

  556. 

  557.         retInfo.bufferSize = gStandalone.engineOptions.audioBufferSize;

  558.         retInfo.sampleRate = gStandalone.engineOptions.audioSampleRate;

  559.     }

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

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

  562. 

  563.     uint index = 0;

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

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

  566.     {

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

  568.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  569. 

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

  571.             break;

  572.     }

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

  574. 

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

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

  577. 

  578.     retInfo.name        = audioDevice;

  579.     retInfo.hints       = devInfo->hints;

  580.     retInfo.bufferSizes = devInfo->bufferSizes;

  581.     retInfo.sampleRates = devInfo->sampleRates;

  582. 

  583.     return &retInfo;

  584. }

  585. 

  586. bool carla_set_engine_buffer_size_and_sample_rate(uint bufferSize, double sampleRate)

  587. {

  588.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, false);

  589.     carla_debug("carla_set_engine_buffer_size_and_sample_rate(%u, %f)", bufferSize, sampleRate);

  590. 

  591.     return gStandalone.engine->setBufferSizeAndSampleRate(bufferSize, sampleRate);

  592. }

  593. 

  594. bool carla_show_engine_device_control_panel()

  595. {

  596.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, false);

  597.     carla_debug("carla_show_engine_device_control_panel()");

  598. 

  599.     return gStandalone.engine->showDeviceControlPanel();

  600. }

  601. #endif

  602. 

  603. void carla_clear_engine_xruns()

  604. {

  605.     if (gStandalone.engine != nullptr)

  606.         gStandalone.engine->clearXruns();

  607. }

  608. 

  609. void carla_cancel_engine_action()

  610. {

  611.     if (gStandalone.engine != nullptr)

  612.         gStandalone.engine->setActionCanceled(true);

  613. }

  614. 

  615. bool carla_set_engine_about_to_close()

  616. {

  617.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, true);

  618.     carla_debug("carla_set_engine_about_to_close()");

  619. 

  620.     return gStandalone.engine->setAboutToClose();

  621. }

  622. 

  623. void carla_set_engine_callback(EngineCallbackFunc func, void* ptr)

  624. {

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

  626. 

  627.     gStandalone.engineCallback    = func;

  628.     gStandalone.engineCallbackPtr = ptr;

  629. 

  630. #ifndef BUILD_BRIDGE

  631.     gStandalone.logThread.setCallback(func, ptr);

  632. #endif

  633. 

  634.     if (gStandalone.engine != nullptr)

  635.         gStandalone.engine->setCallback(func, ptr);

  636. }

  637. 

  638. #ifndef BUILD_BRIDGE

  639. void carla_set_engine_option(EngineOption option, int value, const char* valueStr)

  640. {

  641.     carla_debug("carla_set_engine_option(%i:%s, %i, \"%s\")", option, CB::EngineOption2Str(option), value, valueStr);

  642. 

  643.     switch (option)

  644.     {

  645.     case CB::ENGINE_OPTION_DEBUG:

  646.         break;

  647. 

  648.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

  650.         gStandalone.engineOptions.processMode = static_cast<CB::EngineProcessMode>(value);

  651.         break;

  652. 

  653.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  655. 

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

  657.         if (gStandalone.engineOptions.processMode == CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS

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

  659.         {

  660.             gStandalone.engineOptions.transportMode = CB::ENGINE_TRANSPORT_MODE_JACK;

  661. 

  662.             if (gStandalone.engineCallback != nullptr)

  663.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,

  664.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  665.                                            0,

  666.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  667.                                            0, 0, 0.0f,

  668.                                            gStandalone.engineOptions.transportExtra);

  669.         }

  670.         else

  671.         {

  672.             gStandalone.engineOptions.transportMode = static_cast<CB::EngineTransportMode>(value);

  673.         }

  674. 

  675.         delete[] gStandalone.engineOptions.transportExtra;

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

  677.             gStandalone.engineOptions.transportExtra = carla_strdup_safe(valueStr);

  678.         else

  679.             gStandalone.engineOptions.transportExtra = nullptr;

  680.         break;

  681. 

  682.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

  684.         gStandalone.engineOptions.forceStereo = (value != 0);

  685.         break;

  686. 

  687.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

  689.         gStandalone.engineOptions.preferPluginBridges = (value != 0);

  690.         break;

  691. 

  692.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

  694.         gStandalone.engineOptions.preferUiBridges = (value != 0);

  695.         break;

  696. 

  697.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

  699.         gStandalone.engineOptions.uisAlwaysOnTop = (value != 0);

  700.         break;

  701. 

  702.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  703.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  704.         gStandalone.engineOptions.maxParameters = static_cast<uint>(value);

  705.         break;

  706. 

  707.     case CB::ENGINE_OPTION_RESET_XRUNS:

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

  709.         gStandalone.engineOptions.resetXruns = (value != 0);

  710.         break;

  711. 

  712.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  713.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  714.         gStandalone.engineOptions.uiBridgesTimeout = static_cast<uint>(value);

  715.         break;

  716. 

  717.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  718.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

  719.         gStandalone.engineOptions.audioBufferSize = static_cast<uint>(value);

  720.         break;

  721. 

  722.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  723.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

  724.         gStandalone.engineOptions.audioSampleRate = static_cast<uint>(value);

  725.         break;

  726. 

  727.     case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

  729.         gStandalone.engineOptions.audioTripleBuffer = (value != 0);

  730.         break;

  731. 

  732.     case CB::ENGINE_OPTION_AUDIO_DRIVER:

  733.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  734. 

  735.         if (gStandalone.engineOptions.audioDriver != nullptr)

  736.             delete[] gStandalone.engineOptions.audioDriver;

  737. 

  738.         gStandalone.engineOptions.audioDriver = carla_strdup_safe(valueStr);

  739.         break;

  740. 

  741.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  742.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  743. 

  744.         if (gStandalone.engineOptions.audioDevice != nullptr)

  745.             delete[] gStandalone.engineOptions.audioDevice;

  746. 

  747.         gStandalone.engineOptions.audioDevice = carla_strdup_safe(valueStr);

  748.         break;

  749. 

  750.     case CB::ENGINE_OPTION_OSC_ENABLED:

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

  752.         gStandalone.engineOptions.oscEnabled = (value != 0);

  753.         break;

  754. 

  755.     case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  757.         gStandalone.engineOptions.oscPortTCP = value;

  758.         break;

  759. 

  760.     case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  762.         gStandalone.engineOptions.oscPortUDP = value;

  763.         break;

  764. 

  765.     case CB::ENGINE_OPTION_FILE_PATH:

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

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

  768.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  769. 

  770.         switch (value)

  771.         {

  772.         case CB::FILE_AUDIO:

  773.             if (gStandalone.engineOptions.pathAudio != nullptr)

  774.                 delete[] gStandalone.engineOptions.pathAudio;

  775.             gStandalone.engineOptions.pathAudio = carla_strdup_safe(valueStr);

  776.             break;

  777.         case CB::FILE_MIDI:

  778.             if (gStandalone.engineOptions.pathMIDI != nullptr)

  779.                 delete[] gStandalone.engineOptions.pathMIDI;

  780.             gStandalone.engineOptions.pathMIDI = carla_strdup_safe(valueStr);

  781.             break;

  782.         }

  783.         break;

  784. 

  785.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  788.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  789. 

  790.         switch (value)

  791.         {

  792.         case CB::PLUGIN_LADSPA:

  793.             if (gStandalone.engineOptions.pathLADSPA != nullptr)

  794.                 delete[] gStandalone.engineOptions.pathLADSPA;

  795.             gStandalone.engineOptions.pathLADSPA = carla_strdup_safe(valueStr);

  796.             break;

  797.         case CB::PLUGIN_DSSI:

  798.             if (gStandalone.engineOptions.pathDSSI != nullptr)

  799.                 delete[] gStandalone.engineOptions.pathDSSI;

  800.             gStandalone.engineOptions.pathDSSI = carla_strdup_safe(valueStr);

  801.             break;

  802.         case CB::PLUGIN_LV2:

  803.             if (gStandalone.engineOptions.pathLV2 != nullptr)

  804.                 delete[] gStandalone.engineOptions.pathLV2;

  805.             gStandalone.engineOptions.pathLV2 = carla_strdup_safe(valueStr);

  806.             break;

  807.         case CB::PLUGIN_VST2:

  808.             if (gStandalone.engineOptions.pathVST2 != nullptr)

  809.                 delete[] gStandalone.engineOptions.pathVST2;

  810.             gStandalone.engineOptions.pathVST2 = carla_strdup_safe(valueStr);

  811.             break;

  812.         case CB::PLUGIN_VST3:

  813.             if (gStandalone.engineOptions.pathVST3 != nullptr)

  814.                 delete[] gStandalone.engineOptions.pathVST3;

  815.             gStandalone.engineOptions.pathVST3 = carla_strdup_safe(valueStr);

  816.             break;

  817.         case CB::PLUGIN_SF2:

  818.             if (gStandalone.engineOptions.pathSF2 != nullptr)

  819.                 delete[] gStandalone.engineOptions.pathSF2;

  820.             gStandalone.engineOptions.pathSF2 = carla_strdup_safe(valueStr);

  821.             break;

  822.         case CB::PLUGIN_SFZ:

  823.             if (gStandalone.engineOptions.pathSFZ != nullptr)

  824.                 delete[] gStandalone.engineOptions.pathSFZ;

  825.             gStandalone.engineOptions.pathSFZ = carla_strdup_safe(valueStr);

  826.             break;

  827.         }

  828.         break;

  829. 

  830.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  832. 

  833.         if (gStandalone.engineOptions.binaryDir != nullptr)

  834.             delete[] gStandalone.engineOptions.binaryDir;

  835. 

  836.         gStandalone.engineOptions.binaryDir = carla_strdup_safe(valueStr);

  837.         break;

  838. 

  839.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  841. 

  842.         if (gStandalone.engineOptions.resourceDir != nullptr)

  843.             delete[] gStandalone.engineOptions.resourceDir;

  844. 

  845.         gStandalone.engineOptions.resourceDir = carla_strdup_safe(valueStr);

  846.         break;

  847. 

  848.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

  850.         gStandalone.engineOptions.preventBadBehaviour = (value != 0);

  851.         break;

  852. 

  853.     case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

  854.         gStandalone.engineOptions.bgColor = static_cast<uint>(value);

  855.         break;

  856. 

  857.     case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

  858.         gStandalone.engineOptions.fgColor = static_cast<uint>(value);

  859.         break;

  860. 

  861.     case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  862.         CARLA_SAFE_ASSERT_RETURN(value > 0,);

  863.         gStandalone.engineOptions.uiScale = static_cast<float>(value) / 1000;

  864.         break;

  865. 

  866.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  869.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

  870.         gStandalone.engineOptions.frontendWinId = static_cast<uintptr_t>(winId);

  871.     }   break;

  872. 

  873. #ifndef CARLA_OS_WIN

  874.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  876. 

  877.         if (gStandalone.engineOptions.wine.executable != nullptr)

  878.             delete[] gStandalone.engineOptions.wine.executable;

  879. 

  880.         gStandalone.engineOptions.wine.executable = carla_strdup_safe(valueStr);

  881.         break;

  882. 

  883.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

  885.         gStandalone.engineOptions.wine.autoPrefix = (value != 0);

  886.         break;

  887. 

  888.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  890. 

  891.         if (gStandalone.engineOptions.wine.fallbackPrefix != nullptr)

  892.             delete[] gStandalone.engineOptions.wine.fallbackPrefix;

  893. 

  894.         gStandalone.engineOptions.wine.fallbackPrefix = carla_strdup_safe(valueStr);

  895.         break;

  896. 

  897.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

  899.         gStandalone.engineOptions.wine.rtPrio = (value != 0);

  900.         break;

  901. 

  902.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

  904.         gStandalone.engineOptions.wine.baseRtPrio = value;

  905.         break;

  906. 

  907.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

  909.         gStandalone.engineOptions.wine.serverRtPrio = value;

  910.         break;

  911. #endif

  912. 

  913.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

  914.         gStandalone.logThreadEnabled = (value != 0);

  915.         break;

  916.     }

  917. 

  918.     if (gStandalone.engine != nullptr)

  919.         gStandalone.engine->setOption(option, value, valueStr);

  920. }

  921. #endif

  922. 

  923. void carla_set_file_callback(FileCallbackFunc func, void* ptr)

  924. {

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

  926. 

  927.     gStandalone.fileCallback    = func;

  928.     gStandalone.fileCallbackPtr = ptr;

  929. 

  930.     if (gStandalone.engine != nullptr)

  931.         gStandalone.engine->setFileCallback(func, ptr);

  932. }

  933. 

  934. // --------------------------------------------------------------------------------------------------------------------

  935. 

  936. bool carla_load_file(const char* filename)

  937. {

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

  939.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  940. 

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

  942. 

  943.     return gStandalone.engine->loadFile(filename);

  944. }

  945. 

  946. bool carla_load_project(const char* filename)

  947. {

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

  949.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  950. 

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

  952. 

  953.     return gStandalone.engine->loadProject(filename, true);

  954. }

  955. 

  956. bool carla_save_project(const char* filename)

  957. {

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

  959.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  960. 

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

  962. 

  963.     return gStandalone.engine->saveProject(filename, true);

  964. }

  965. 

  966. #ifndef BUILD_BRIDGE

  967. void carla_clear_project_filename()

  968. {

  969.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  970. 

  971.     carla_debug("carla_clear_project_filename()");

  972. 

  973.     gStandalone.engine->clearCurrentProjectFilename();

  974. }

  975. 

  976. // --------------------------------------------------------------------------------------------------------------------

  977. 

  978. bool carla_patchbay_connect(bool external, uint groupIdA, uint portIdA, uint groupIdB, uint portIdB)

  979. {

  980.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  981. 

  982.     carla_debug("carla_patchbay_connect(%s, %u, %u, %u, %u)",

  983.                 bool2str(external), groupIdA, portIdA, groupIdB, portIdB);

  984. 

  985.     return gStandalone.engine->patchbayConnect(external, groupIdA, portIdA, groupIdB, portIdB);

  986. }

  987. 

  988. bool carla_patchbay_disconnect(bool external, uint connectionId)

  989. {

  990.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  991. 

  992.     carla_debug("carla_patchbay_disconnect(%s, %i)", bool2str(external), connectionId);

  993. 

  994.     return gStandalone.engine->patchbayDisconnect(external, connectionId);

  995. }

  996. 

  997. bool carla_patchbay_refresh(bool external)

  998. {

  999.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1000. 

  1001.     carla_debug("carla_patchbay_refresh(%s)", bool2str(external));

  1002. 

  1003.     return gStandalone.engine->patchbayRefresh(true, false, external);

  1004. }

  1005. 

  1006. // --------------------------------------------------------------------------------------------------------------------

  1007. 

  1008. void carla_transport_play()

  1009. {

  1010.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1011. 

  1012.     carla_debug("carla_transport_play()");

  1013. 

  1014.     gStandalone.engine->transportPlay();

  1015. }

  1016. 

  1017. void carla_transport_pause()

  1018. {

  1019.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1020. 

  1021.     carla_debug("carla_transport_pause()");

  1022. 

  1023.     gStandalone.engine->transportPause();

  1024. }

  1025. 

  1026. void carla_transport_bpm(double bpm)

  1027. {

  1028.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1029. 

  1030.     carla_debug("carla_transport_bpm(%f)", bpm);

  1031. 

  1032.     gStandalone.engine->transportBPM(bpm);

  1033. }

  1034. 

  1035. void carla_transport_relocate(uint64_t frame)

  1036. {

  1037.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  1038. 

  1039.     carla_debug("carla_transport_relocate(%i)", frame);

  1040. 

  1041.     gStandalone.engine->transportRelocate(frame);

  1042. }

  1043. 

  1044. uint64_t carla_get_current_transport_frame()

  1045. {

  1046.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(), 0);

  1047. 

  1048.     return gStandalone.engine->getTimeInfo().frame;

  1049. }

  1050. 

  1051. const CarlaTransportInfo* carla_get_transport_info()

  1052. {

  1053.     static CarlaTransportInfo retTransInfo;

  1054.     retTransInfo.clear();

  1055. 

  1056.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(), &retTransInfo);

  1057. 

  1058.     const CB::EngineTimeInfo& timeInfo(gStandalone.engine->getTimeInfo());

  1059. 

  1060.     retTransInfo.playing = timeInfo.playing;

  1061.     retTransInfo.frame   = timeInfo.frame;

  1062. 

  1063.     if (timeInfo.bbt.valid)

  1064.     {

  1065.         retTransInfo.bar  = timeInfo.bbt.bar;

  1066.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1069.     }

  1070. 

  1071.     return &retTransInfo;

  1072. }

  1073. #endif

  1074. 

  1075. // --------------------------------------------------------------------------------------------------------------------

  1076. 

  1077. uint32_t carla_get_current_plugin_count()

  1078. {

  1079.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1080. 

  1081.     carla_debug("carla_get_current_plugin_count()");

  1082. 

  1083.     return gStandalone.engine->getCurrentPluginCount();

  1084. }

  1085. 

  1086. uint32_t carla_get_max_plugin_number()

  1087. {

  1088.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1089. 

  1090.     carla_debug("carla_get_max_plugin_number()");

  1091. 

  1092.     return gStandalone.engine->getMaxPluginNumber();

  1093. }

  1094. 

  1095. // --------------------------------------------------------------------------------------------------------------------

  1096. 

  1097. bool carla_add_plugin(BinaryType btype, PluginType ptype,

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

  1099.                       const void* extraPtr, uint options)

  1100. {

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

  1102. 

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

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

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

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

  1107. 

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

  1109. }

  1110. 

  1111. bool carla_remove_plugin(uint pluginId)

  1112. {

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

  1114. 

  1115.     carla_debug("carla_remove_plugin(%i)", pluginId);

  1116. 

  1117.     return gStandalone.engine->removePlugin(pluginId);

  1118. }

  1119. 

  1120. bool carla_remove_all_plugins()

  1121. {

  1122.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1123. 

  1124.     carla_debug("carla_remove_all_plugins()");

  1125. 

  1126.     return gStandalone.engine->removeAllPlugins();

  1127. }

  1128. 

  1129. #ifndef BUILD_BRIDGE

  1130. bool carla_rename_plugin(uint pluginId, const char* newName)

  1131. {

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

  1133.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1134. 

  1135.     carla_debug("carla_rename_plugin(%i, \"%s\")", pluginId, newName);

  1136. 

  1137.     return gStandalone.engine->renamePlugin(pluginId, newName);

  1138. }

  1139. 

  1140. bool carla_clone_plugin(uint pluginId)

  1141. {

  1142.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1143. 

  1144.     carla_debug("carla_clone_plugin(%i)", pluginId);

  1145. 

  1146.     return gStandalone.engine->clonePlugin(pluginId);

  1147. }

  1148. 

  1149. bool carla_replace_plugin(uint pluginId)

  1150. {

  1151.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1152. 

  1153.     carla_debug("carla_replace_plugin(%i)", pluginId);

  1154. 

  1155.     return gStandalone.engine->replacePlugin(pluginId);

  1156. }

  1157. 

  1158. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1159. {

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

  1161.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1162. 

  1163.     carla_debug("carla_switch_plugins(%i, %i)", pluginIdA, pluginIdB);

  1164. 

  1165.     return gStandalone.engine->switchPlugins(pluginIdA, pluginIdB);

  1166. }

  1167. #endif

  1168. 

  1169. // --------------------------------------------------------------------------------------------------------------------

  1170. 

  1171. bool carla_load_plugin_state(uint pluginId, const char* filename)

  1172. {

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

  1174.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr

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

  1176. 

  1177.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1179. 

  1180.     carla_debug("carla_load_plugin_state(%i, \"%s\")", pluginId, filename);

  1181. 

  1182.     return plugin->loadStateFromFile(filename);

  1183. }

  1184. 

  1185. bool carla_save_plugin_state(uint pluginId, const char* filename)

  1186. {

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

  1188.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1189. 

  1190.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1192. 

  1193.     carla_debug("carla_save_plugin_state(%i, \"%s\")", pluginId, filename);

  1194. 

  1195.     return plugin->saveStateToFile(filename);

  1196. }

  1197. 

  1198. bool carla_export_plugin_lv2(uint pluginId, const char* lv2path)

  1199. {

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

  1201.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr, "Engine is not initialized", false);

  1202. 

  1203.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1205. 

  1206.     carla_debug("carla_export_plugin_lv2(%i, \"%s\")", pluginId, lv2path);

  1207. 

  1208.     return plugin->exportAsLV2(lv2path);

  1209. }

  1210. 

  1211. // --------------------------------------------------------------------------------------------------------------------

  1212. 

  1213. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1214. {

  1215.     static CarlaPluginInfo retInfo;

  1216. 

  1217.     // reset

  1218.     retInfo.type             = CB::PLUGIN_NONE;

  1219.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1220.     retInfo.hints            = 0x0;

  1221.     retInfo.optionsAvailable = 0x0;

  1222.     retInfo.optionsEnabled   = 0x0;

  1223.     retInfo.filename         = gNullCharPtr;

  1224.     retInfo.name             = gNullCharPtr;

  1225.     retInfo.iconName         = gNullCharPtr;

  1226.     retInfo.uniqueId         = 0;

  1227. 

  1228.     // cleanup

  1229.     if (retInfo.label != gNullCharPtr)

  1230.     {

  1231.         delete[] retInfo.label;

  1232.         retInfo.label = gNullCharPtr;

  1233.     }

  1234. 

  1235.     if (retInfo.maker != gNullCharPtr)

  1236.     {

  1237.         delete[] retInfo.maker;

  1238.         retInfo.maker = gNullCharPtr;

  1239.     }

  1240. 

  1241.     if (retInfo.copyright != gNullCharPtr)

  1242.     {

  1243.         delete[] retInfo.copyright;

  1244.         retInfo.copyright = gNullCharPtr;

  1245.     }

  1246. 

  1247.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1248. 

  1249.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1251. 

  1252.     carla_debug("carla_get_plugin_info(%i)", pluginId);

  1253. 

  1254.     char strBuf[STR_MAX+1];

  1255.     carla_zeroChars(strBuf, STR_MAX+1);

  1256. 

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

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

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

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

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

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

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

  1264. 

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

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

  1267. 

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

  1269.         retInfo.label = carla_strdup_safe(strBuf);

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

  1271.         retInfo.maker = carla_strdup_safe(strBuf);

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

  1273.         retInfo.copyright = carla_strdup_safe(strBuf);

  1274. 

  1275.     checkStringPtr(retInfo.filename);

  1276.     checkStringPtr(retInfo.name);

  1277.     checkStringPtr(retInfo.iconName);

  1278.     checkStringPtr(retInfo.label);

  1279.     checkStringPtr(retInfo.maker);

  1280.     checkStringPtr(retInfo.copyright);

  1281. 

  1282.     return &retInfo;

  1283. }

  1284. 

  1285. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1286. {

  1287.     static CarlaPortCountInfo retInfo;

  1288.     carla_zeroStruct(retInfo);

  1289. 

  1290.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1291. 

  1292.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1294. 

  1295.     carla_debug("carla_get_audio_port_count_info(%i)", pluginId);

  1296. 

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

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

  1299.     return &retInfo;

  1300. }

  1301. 

  1302. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1303. {

  1304.     static CarlaPortCountInfo retInfo;

  1305.     carla_zeroStruct(retInfo);

  1306. 

  1307.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1308. 

  1309.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1311. 

  1312.     carla_debug("carla_get_midi_port_count_info(%i)", pluginId);

  1313. 

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

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

  1316.     return &retInfo;

  1317. }

  1318. 

  1319. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1320. {

  1321.     static CarlaPortCountInfo retInfo;

  1322.     carla_zeroStruct(retInfo);

  1323. 

  1324.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1325. 

  1326.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1328. 

  1329.     carla_debug("carla_get_parameter_count_info(%i)", pluginId);

  1330. 

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

  1332.     return &retInfo;

  1333. }

  1334. 

  1335. const CarlaParameterInfo* carla_get_parameter_info(uint pluginId, uint32_t parameterId)

  1336. {

  1337.     static CarlaParameterInfo retInfo;

  1338. 

  1339.     // reset

  1340.     retInfo.scalePointCount = 0;

  1341. 

  1342.     // cleanup

  1343.     if (retInfo.name != gNullCharPtr)

  1344.     {

  1345.         delete[] retInfo.name;

  1346.         retInfo.name = gNullCharPtr;

  1347.     }

  1348. 

  1349.     if (retInfo.symbol != gNullCharPtr)

  1350.     {

  1351.         delete[] retInfo.symbol;

  1352.         retInfo.symbol = gNullCharPtr;

  1353.     }

  1354. 

  1355.     if (retInfo.unit != gNullCharPtr)

  1356.     {

  1357.         delete[] retInfo.unit;

  1358.         retInfo.unit = gNullCharPtr;

  1359.     }

  1360. 

  1361.     if (retInfo.comment != gNullCharPtr)

  1362.     {

  1363.         delete[] retInfo.comment;

  1364.         retInfo.comment = gNullCharPtr;

  1365.     }

  1366. 

  1367.     if (retInfo.groupName != gNullCharPtr)

  1368.     {

  1369.         delete[] retInfo.groupName;

  1370.         retInfo.groupName = gNullCharPtr;

  1371.     }

  1372. 

  1373.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1374. 

  1375.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1377. 

  1378.     carla_debug("carla_get_parameter_info(%i, %i)", pluginId, parameterId);

  1379. 

  1380.     char strBuf[STR_MAX+1];

  1381.     carla_zeroChars(strBuf, STR_MAX+1);

  1382. 

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

  1384. 

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

  1386.     {

  1387.         retInfo.name = carla_strdup_safe(strBuf);

  1388.         carla_zeroChars(strBuf, STR_MAX+1);

  1389.     }

  1390. 

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

  1392.     {

  1393.         retInfo.symbol = carla_strdup_safe(strBuf);

  1394.         carla_zeroChars(strBuf, STR_MAX+1);

  1395.     }

  1396. 

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

  1398.     {

  1399.         retInfo.unit = carla_strdup_safe(strBuf);

  1400.         carla_zeroChars(strBuf, STR_MAX+1);

  1401.     }

  1402. 

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

  1404.     {

  1405.         retInfo.comment = carla_strdup_safe(strBuf);

  1406.         carla_zeroChars(strBuf, STR_MAX+1);

  1407.     }

  1408. 

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

  1410.     {

  1411.         retInfo.groupName = carla_strdup_safe(strBuf);

  1412.         carla_zeroChars(strBuf, STR_MAX+1);

  1413.     }

  1414. 

  1415.     checkStringPtr(retInfo.name);

  1416.     checkStringPtr(retInfo.symbol);

  1417.     checkStringPtr(retInfo.unit);

  1418.     checkStringPtr(retInfo.comment);

  1419.     checkStringPtr(retInfo.groupName);

  1420. 

  1421.     return &retInfo;

  1422. }

  1423. 

  1424. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(uint pluginId, uint32_t parameterId, uint32_t scalePointId)

  1425. {

  1426.     CARLA_ASSERT(gStandalone.engine != nullptr);

  1427. 

  1428.     static CarlaScalePointInfo retInfo;

  1429. 

  1430.     // reset

  1431.     retInfo.value = 0.0f;

  1432. 

  1433.     // cleanup

  1434.     if (retInfo.label != gNullCharPtr)

  1435.     {

  1436.         delete[] retInfo.label;

  1437.         retInfo.label = gNullCharPtr;

  1438.     }

  1439. 

  1440.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retInfo);

  1441. 

  1442.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1444. 

  1445.     carla_debug("carla_get_parameter_scalepoint_info(%i, %i, %i)", pluginId, parameterId, scalePointId);

  1446. 

  1447.     char strBuf[STR_MAX+1];

  1448. 

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

  1450. 

  1451.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1453.         retInfo.label = carla_strdup_safe(strBuf);

  1454. 

  1455.     checkStringPtr(retInfo.label);

  1456. 

  1457.     return &retInfo;

  1458. }

  1459. 

  1460. // --------------------------------------------------------------------------------------------------------------------

  1461. 

  1462. const ParameterData* carla_get_parameter_data(uint pluginId, uint32_t parameterId)

  1463. {

  1464.     static ParameterData retParamData;

  1465. 

  1466.     // reset

  1467.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1468.     retParamData.hints       = 0x0;

  1469.     retParamData.index       = CB::PARAMETER_NULL;

  1470.     retParamData.rindex      = -1;

  1471.     retParamData.midiChannel = 0;

  1472.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1473.     retParamData.mappedMinimum = 0.0f;

  1474.     retParamData.mappedMaximum = 0.0f;

  1475. 

  1476.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retParamData);

  1477. 

  1478.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1480. 

  1481.     carla_debug("carla_get_parameter_data(%i, %i)", pluginId, parameterId);

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

  1483. 

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

  1485.     retParamData.type        = pluginParamData.type;

  1486.     retParamData.hints       = pluginParamData.hints;

  1487.     retParamData.index       = pluginParamData.index;

  1488.     retParamData.rindex      = pluginParamData.rindex;

  1489.     retParamData.midiChannel = pluginParamData.midiChannel;

  1490.     retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1491.     retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1492.     retParamData.mappedMaximum = pluginParamData.mappedMaximum;

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

  1494. }

  1495. 

  1496. const ParameterRanges* carla_get_parameter_ranges(uint pluginId, uint32_t parameterId)

  1497. {

  1498.     static ParameterRanges retParamRanges;

  1499. 

  1500.     // reset

  1501.     retParamRanges.def       = 0.0f;

  1502.     retParamRanges.min       = 0.0f;

  1503.     retParamRanges.max       = 1.0f;

  1504.     retParamRanges.step      = 0.01f;

  1505.     retParamRanges.stepSmall = 0.0001f;

  1506.     retParamRanges.stepLarge = 0.1f;

  1507. 

  1508.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retParamRanges);

  1509. 

  1510.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1512. 

  1513.     carla_debug("carla_get_parameter_ranges(%i, %i)", pluginId, parameterId);

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

  1515. 

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

  1517.     retParamRanges.def       = pluginParamRanges.def;

  1518.     retParamRanges.min       = pluginParamRanges.min;

  1519.     retParamRanges.max       = pluginParamRanges.max;

  1520.     retParamRanges.step      = pluginParamRanges.step;

  1521.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1522.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1523.     return &pluginParamRanges;

  1524. }

  1525. 

  1526. const MidiProgramData* carla_get_midi_program_data(uint pluginId, uint32_t midiProgramId)

  1527. {

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

  1529. 

  1530.     // reset

  1531.     retMidiProgData.bank    = 0;

  1532.     retMidiProgData.program = 0;

  1533. 

  1534.     if (retMidiProgData.name != gNullCharPtr)

  1535.     {

  1536.         delete[] retMidiProgData.name;

  1537.         retMidiProgData.name = gNullCharPtr;

  1538.     }

  1539. 

  1540.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retMidiProgData);

  1541. 

  1542.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1544. 

  1545.     carla_debug("carla_get_midi_program_data(%i, %i)", pluginId, midiProgramId);

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

  1547. 

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

  1549.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1550.     retMidiProgData.program = pluginMidiProgData.program;

  1551. 

  1552.     if (pluginMidiProgData.name != nullptr)

  1553.     {

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

  1555.         checkStringPtr(retMidiProgData.name);

  1556.     }

  1557.     else

  1558.     {

  1559.         retMidiProgData.name = gNullCharPtr;

  1560.     }

  1561. 

  1562.     return &retMidiProgData;

  1563. }

  1564. 

  1565. const CustomData* carla_get_custom_data(uint pluginId, uint32_t customDataId)

  1566. {

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

  1568. 

  1569.     // reset

  1570.     if (retCustomData.type != gNullCharPtr)

  1571.     {

  1572.         delete[] retCustomData.type;

  1573.         retCustomData.type = gNullCharPtr;

  1574.     }

  1575. 

  1576.     if (retCustomData.key != gNullCharPtr)

  1577.     {

  1578.         delete[] retCustomData.key;

  1579.         retCustomData.key = gNullCharPtr;

  1580.     }

  1581. 

  1582.     if (retCustomData.value != gNullCharPtr)

  1583.     {

  1584.         delete[] retCustomData.value;

  1585.         retCustomData.value = gNullCharPtr;

  1586.     }

  1587. 

  1588.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &retCustomData);

  1589. 

  1590.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1592. 

  1593.     carla_debug("carla_get_custom_data(%i, %i)", pluginId, customDataId);

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

  1595. 

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

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

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

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

  1600.     checkStringPtr(retCustomData.type);

  1601.     checkStringPtr(retCustomData.key);

  1602.     checkStringPtr(retCustomData.value);

  1603.     return &retCustomData;

  1604. }

  1605. 

  1606. const char* carla_get_custom_data_value(uint pluginId, const char* type, const char* key)

  1607. {

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

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

  1610.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1611. 

  1612.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1614. 

  1615.     carla_debug("carla_get_custom_data_value(%i, %s, %s)", pluginId, type, key);

  1616. 

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

  1618. 

  1619.     if (count == 0)

  1620.         return gNullCharPtr;

  1621. 

  1622.     static CarlaString customDataValue;

  1623. 

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

  1625.     {

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

  1627. 

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

  1629.             continue;

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

  1631.             continue;

  1632. 

  1633.         customDataValue = pluginCustomData.value;

  1634.         return customDataValue.buffer();

  1635.     }

  1636. 

  1637.     return gNullCharPtr;

  1638. }

  1639. 

  1640. const char* carla_get_chunk_data(uint pluginId)

  1641. {

  1642.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1643. 

  1644.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1646. 

  1647.     carla_debug("carla_get_chunk_data(%i)", pluginId);

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

  1649. 

  1650.     void* data = nullptr;

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

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

  1653. 

  1654.     static CarlaString chunkData;

  1655. 

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

  1657.     return chunkData.buffer();

  1658. }

  1659. 

  1660. // --------------------------------------------------------------------------------------------------------------------

  1661. 

  1662. uint32_t carla_get_parameter_count(uint pluginId)

  1663. {

  1664.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1665. 

  1666.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1668. 

  1669.     carla_debug("carla_get_parameter_count(%i)", pluginId);

  1670.     return plugin->getParameterCount();

  1671. }

  1672. 

  1673. uint32_t carla_get_program_count(uint pluginId)

  1674. {

  1675.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1676. 

  1677.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1679. 

  1680.     carla_debug("carla_get_program_count(%i)", pluginId);

  1681.     return plugin->getProgramCount();

  1682. }

  1683. 

  1684. uint32_t carla_get_midi_program_count(uint pluginId)

  1685. {

  1686.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1687. 

  1688.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1690. 

  1691.     carla_debug("carla_get_midi_program_count(%i)", pluginId);

  1692.     return plugin->getMidiProgramCount();

  1693. }

  1694. 

  1695. uint32_t carla_get_custom_data_count(uint pluginId)

  1696. {

  1697.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  1698. 

  1699.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1701. 

  1702.     carla_debug("carla_get_custom_data_count(%i)", pluginId);

  1703.     return plugin->getCustomDataCount();

  1704. }

  1705. 

  1706. // --------------------------------------------------------------------------------------------------------------------

  1707. 

  1708. const char* carla_get_parameter_text(uint pluginId, uint32_t parameterId)

  1709. {

  1710.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1711. 

  1712.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1714. 

  1715.     carla_debug("carla_get_parameter_text(%i, %i)", pluginId, parameterId);

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

  1717. 

  1718.     static char textBuf[STR_MAX+1];

  1719.     carla_zeroChars(textBuf, STR_MAX+1);

  1720. 

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

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

  1723. 

  1724.     return textBuf;

  1725. }

  1726. 

  1727. const char* carla_get_program_name(uint pluginId, uint32_t programId)

  1728. {

  1729.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  1730. 

  1731.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1733. 

  1734.     carla_debug("carla_get_program_name(%i, %i)", pluginId, programId);

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

  1736. 

  1737.     static char programName[STR_MAX+1];

  1738.     carla_zeroChars(programName, STR_MAX+1);

  1739. 

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

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

  1742. 

  1743.     return programName;

  1744. }

  1745. 

  1746. const char* carla_get_midi_program_name(uint pluginId, uint32_t midiProgramId)

  1747. {

  1748.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1749. 

  1750.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1752. 

  1753.     carla_debug("carla_get_midi_program_name(%i, %i)", pluginId, midiProgramId);

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

  1755. 

  1756.     static char midiProgramName[STR_MAX+1];

  1757.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1758. 

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

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

  1761. 

  1762.     return midiProgramName;

  1763. }

  1764. 

  1765. const char* carla_get_real_plugin_name(uint pluginId)

  1766. {

  1767.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, gNullCharPtr);

  1768. 

  1769.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1771. 

  1772.     carla_debug("carla_get_real_plugin_name(%i)", pluginId);

  1773.     static char realPluginName[STR_MAX+1];

  1774.     carla_zeroChars(realPluginName, STR_MAX+1);

  1775. 

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

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

  1778. 

  1779.     return realPluginName;

  1780. }

  1781. 

  1782. // --------------------------------------------------------------------------------------------------------------------

  1783. 

  1784. int32_t carla_get_current_program_index(uint pluginId)

  1785. {

  1786.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, -1);

  1787. 

  1788.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1790. 

  1791.     carla_debug("carla_get_current_program_index(%i)", pluginId);

  1792.     return plugin->getCurrentProgram();

  1793. }

  1794. 

  1795. int32_t carla_get_current_midi_program_index(uint pluginId)

  1796. {

  1797.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, -1);

  1798. 

  1799.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1801. 

  1802.     carla_debug("carla_get_current_midi_program_index(%i)", pluginId);

  1803.     return plugin->getCurrentMidiProgram();

  1804. }

  1805. 

  1806. // --------------------------------------------------------------------------------------------------------------------

  1807. 

  1808. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1809. {

  1810.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  1811. 

  1812.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1814. 

  1815.     carla_debug("carla_get_default_parameter_value(%i, %i)", pluginId, parameterId);

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

  1817. 

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

  1819. }

  1820. 

  1821. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1822. {

  1823.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  1824. 

  1825.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

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

  1828. 

  1829.     return plugin->getParameterValue(parameterId);

  1830. }

  1831. 

  1832. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1833. {

  1834. #ifdef BUILD_BRIDGE

  1835.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  1836. #else

  1837.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, (parameterId == CB::PARAMETER_CTRL_CHANNEL) ? -1.0f : 0.0f);

  1838. #endif

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

  1840. 

  1841.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1843. 

  1844.     carla_debug("carla_get_internal_parameter_value(%i, %i)", pluginId, parameterId);

  1845.     return plugin->getInternalParameterValue(parameterId);

  1846. }

  1847. 

  1848. // --------------------------------------------------------------------------------------------------------------------

  1849. 

  1850. const float* carla_get_peak_values(uint pluginId)

  1851. {

  1852.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  1853. 

  1854.     return gStandalone.engine->getPeaks(pluginId);

  1855. }

  1856. 

  1857. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1858. {

  1859.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  1860. 

  1861.     return gStandalone.engine->getInputPeak(pluginId, isLeft);

  1862. }

  1863. 

  1864. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1865. {

  1866.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0f);

  1867. 

  1868.     return gStandalone.engine->getOutputPeak(pluginId, isLeft);

  1869. }

  1870. 

  1871. // --------------------------------------------------------------------------------------------------------------------

  1872. 

  1873. CARLA_BACKEND_START_NAMESPACE

  1874. 

  1875. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1876. // defined in CarlaPluginInternal.cpp

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

  1878. #endif

  1879. 

  1880. // defined in CarlaPluginLV2.cpp

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

  1882. 

  1883. CARLA_BACKEND_END_NAMESPACE

  1884. 

  1885. const CarlaInlineDisplayImageSurface* carla_render_inline_display(uint pluginId, uint32_t width, uint32_t height)

  1886. {

  1887.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, nullptr);

  1888. 

  1889.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

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

  1891. 

  1892.     carla_debug("carla_render_inline_display(%i, %i, %i)", pluginId, width, height);

  1893. 

  1894.     switch (plugin->getType())

  1895.     {

  1896. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1897.     case CB::PLUGIN_INTERNAL:

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

  1899. #endif

  1900.     case CB::PLUGIN_LV2:

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

  1902.     default:

  1903.         return nullptr;

  1904.     }

  1905. }

  1906. 

  1907. // --------------------------------------------------------------------------------------------------------------------

  1908. 

  1909. void carla_set_active(uint pluginId, bool onOff)

  1910. {

  1911.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1912. 

  1913.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1914.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1915. 

  1916.     carla_debug("carla_set_active(%i, %s)", pluginId, bool2str(onOff));

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

  1918. }

  1919. 

  1920. #ifndef BUILD_BRIDGE

  1921. void carla_set_drywet(uint pluginId, float value)

  1922. {

  1923.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1924. 

  1925.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1926.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1927. 

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

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

  1930. }

  1931. 

  1932. void carla_set_volume(uint pluginId, float value)

  1933. {

  1934.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1935. 

  1936.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1937.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1938. 

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

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

  1941. }

  1942. 

  1943. void carla_set_balance_left(uint pluginId, float value)

  1944. {

  1945.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1946. 

  1947.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1948.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1949. 

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

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

  1952. }

  1953. 

  1954. void carla_set_balance_right(uint pluginId, float value)

  1955. {

  1956.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1957. 

  1958.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1959.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1960. 

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

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

  1963. }

  1964. 

  1965. void carla_set_panning(uint pluginId, float value)

  1966. {

  1967.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1968. 

  1969.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1970.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1971. 

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

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

  1974. }

  1975. 

  1976. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1977. {

  1978.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

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

  1980. 

  1981.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1982.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1983. 

  1984.     carla_debug("carla_set_ctrl_channel(%i, %i)", pluginId, channel);

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

  1986. }

  1987. #endif

  1988. 

  1989. void carla_set_option(uint pluginId, uint option, bool yesNo)

  1990. {

  1991.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  1992. 

  1993.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  1994.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1995. 

  1996.     carla_debug("carla_set_option(%i, %i, %s)", pluginId, option, bool2str(yesNo));

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

  1998. }

  1999. 

  2000. // --------------------------------------------------------------------------------------------------------------------

  2001. 

  2002. void carla_set_parameter_value(uint pluginId, uint32_t parameterId, float value)

  2003. {

  2004.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2005. 

  2006.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2007.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2008. 

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

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

  2011. 

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

  2013. }

  2014. 

  2015. #ifndef BUILD_BRIDGE

  2016. 

  2017. void carla_set_parameter_midi_channel(uint pluginId, uint32_t parameterId, uint8_t channel)

  2018. {

  2019.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2020.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2021. 

  2022.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2023.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2024. 

  2025.     carla_debug("carla_set_parameter_midi_channel(%i, %i, %i)", pluginId, parameterId, channel);

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

  2027. 

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

  2029. }

  2030. 

  2031. void carla_set_parameter_mapped_control_index(uint pluginId, uint32_t parameterId, int16_t index)

  2032. {

  2033.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

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

  2035. 

  2036.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2037.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2038. 

  2039.     carla_debug("carla_set_parameter_mapped_control_index(%i, %i, %i)", pluginId, parameterId, index);

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

  2041. 

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

  2043. }

  2044. 

  2045. void carla_set_parameter_mapped_range(uint pluginId, uint32_t parameterId, float minimum, float maximum)

  2046. {

  2047.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2048. 

  2049.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2050.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2051. 

  2052.     carla_debug("carla_set_parameter_mapped_range(%i, %i, %f, %f)", pluginId, parameterId, static_cast<double>(minimum), static_cast<double>(maximum));

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

  2054. 

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

  2056. }

  2057. 

  2058. void carla_set_parameter_touch(uint pluginId, uint32_t parameterId, bool touch)

  2059. {

  2060.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2061. 

  2062.     carla_debug("carla_set_parameter_touch(%i, %i, %s)", pluginId, parameterId, bool2str(touch));

  2063.     return gStandalone.engine->touchPluginParameter(pluginId, parameterId, touch);

  2064. }

  2065. #endif

  2066. 

  2067. // --------------------------------------------------------------------------------------------------------------------

  2068. 

  2069. void carla_set_program(uint pluginId, uint32_t programId)

  2070. {

  2071.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2072. 

  2073.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2074.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2075. 

  2076.     carla_debug("carla_set_program(%i, %i)", pluginId, programId);

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

  2078. 

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

  2080. }

  2081. 

  2082. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2083. {

  2084.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2085. 

  2086.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2087.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2088. 

  2089.     carla_debug("carla_set_midi_program(%i, %i)", pluginId, midiProgramId);

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

  2091. 

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

  2093. }

  2094. 

  2095. // --------------------------------------------------------------------------------------------------------------------

  2096. 

  2097. void carla_set_custom_data(uint pluginId, const char* type, const char* key, const char* value)

  2098. {

  2099.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

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

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

  2102.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2103. 

  2104.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2105.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2106. 

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

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

  2109. }

  2110. 

  2111. void carla_set_chunk_data(uint pluginId, const char* chunkData)

  2112. {

  2113.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

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

  2115. 

  2116.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2117.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2118. 

  2119.     carla_debug("carla_set_chunk_data(%i, \"%s\")", pluginId, chunkData);

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

  2121. 

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

  2123. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2125. #else

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

  2127. #endif

  2128. }

  2129. 

  2130. // --------------------------------------------------------------------------------------------------------------------

  2131. 

  2132. void carla_prepare_for_save(uint pluginId)

  2133. {

  2134.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2135. 

  2136.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2137.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2138. 

  2139.     carla_debug("carla_prepare_for_save(%i)", pluginId);

  2140.     return plugin->prepareForSave();

  2141. }

  2142. 

  2143. void carla_reset_parameters(uint pluginId)

  2144. {

  2145.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2146. 

  2147.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2148.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2149. 

  2150.     carla_debug("carla_reset_parameters(%i)", pluginId);

  2151.     return plugin->resetParameters();

  2152. }

  2153. 

  2154. void carla_randomize_parameters(uint pluginId)

  2155. {

  2156.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2157. 

  2158.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2159.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2160. 

  2161.     carla_debug("carla_randomize_parameters(%i)", pluginId);

  2162.     return plugin->randomizeParameters();

  2163. }

  2164. 

  2165. #ifndef BUILD_BRIDGE

  2166. void carla_send_midi_note(uint pluginId, uint8_t channel, uint8_t note, uint8_t velocity)

  2167. {

  2168.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr && gStandalone.engine->isRunning(),);

  2169. 

  2170.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2171.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2172. 

  2173.     carla_debug("carla_send_midi_note(%i, %i, %i, %i)", pluginId, channel, note, velocity);

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

  2175. }

  2176. #endif

  2177. 

  2178. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2179. {

  2180.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr,);

  2181. 

  2182.     CarlaPlugin* const plugin(gStandalone.engine->getPlugin(pluginId));

  2183.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2184. 

  2185.     carla_debug("carla_show_custom_ui(%i, %s)", pluginId, bool2str(yesNo));

  2186.     return plugin->showCustomUI(yesNo);

  2187. }

  2188. 

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

  2190. 

  2191. uint32_t carla_get_buffer_size()

  2192. {

  2193.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0);

  2194. 

  2195.     carla_debug("carla_get_buffer_size()");

  2196.     return gStandalone.engine->getBufferSize();

  2197. }

  2198. 

  2199. double carla_get_sample_rate()

  2200. {

  2201.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, 0.0);

  2202. 

  2203.     carla_debug("carla_get_sample_rate()");

  2204.     return gStandalone.engine->getSampleRate();

  2205. }

  2206. 

  2207. // --------------------------------------------------------------------------------------------------------------------

  2208. 

  2209. const char* carla_get_last_error()

  2210. {

  2211.     carla_debug("carla_get_last_error()");

  2212. 

  2213.     if (gStandalone.engine != nullptr)

  2214.         return gStandalone.engine->getLastError();

  2215. 

  2216.     return gStandalone.lastError;

  2217. }

  2218. 

  2219. const char* carla_get_host_osc_url_tcp()

  2220. {

  2221.     carla_debug("carla_get_host_osc_url_tcp()");

  2222. 

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

  2224.     if (gStandalone.engine == nullptr)

  2225.     {

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

  2227.         gStandalone.lastError = "Engine is not running";

  2228.         return gNullCharPtr;

  2229.     }

  2230. 

  2231.     const char* const path = gStandalone.engine->getOscServerPathTCP();

  2232. 

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

  2234.         return path;

  2235. 

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

  2237.     return notAvailable;

  2238. #else

  2239.     return gNullCharPtr;

  2240. #endif

  2241. }

  2242. 

  2243. const char* carla_get_host_osc_url_udp()

  2244. {

  2245.     carla_debug("carla_get_host_osc_url_udp()");

  2246. 

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

  2248.     if (gStandalone.engine == nullptr)

  2249.     {

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

  2251.         gStandalone.lastError = "Engine is not running";

  2252.         return gNullCharPtr;

  2253.     }

  2254. 

  2255.     const char* const path = gStandalone.engine->getOscServerPathUDP();

  2256. 

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

  2258.         return path;

  2259. 

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

  2261.     return notAvailable;

  2262. #else

  2263.     return gNullCharPtr;

  2264. #endif

  2265. }

  2266. 

  2267. // --------------------------------------------------------------------------------------------------------------------

  2268. 

  2269. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2270. #include "CarlaPluginUI.cpp"

  2271. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2272. 

  2273. #include "CarlaDssiUtils.cpp"

  2274. #include "CarlaMacUtils.cpp"

  2275. #include "CarlaPatchbayUtils.cpp"

  2276. #include "CarlaPipeUtils.cpp"

  2277. #include "CarlaStateUtils.cpp"

  2278. 

  2279. // --------------------------------------------------------------------------------------------------------------------