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

2301 lines
86KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHostImpl.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngineInit.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #ifdef BUILD_BRIDGE

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

  33. #else

  34. # include "CarlaLogThread.hpp"

  35. #endif

  36. 

  37. #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.         if (handle->isStandalone)                                \

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

  59.         return ret;                                              \

  60.     }

  61. 

  62. // --------------------------------------------------------------------------------------------------------------------

  63. // API

  64. 

  65. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  66. #include "CarlaHostCommon.cpp"

  67. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  68. 

  69. // --------------------------------------------------------------------------------------------------------------------

  70. 

  71. uint carla_get_engine_driver_count()

  72. {

  73.     carla_debug("carla_get_engine_driver_count()");

  74. 

  75.     return CarlaEngine::getDriverCount();

  76. }

  77. 

  78. const char* carla_get_engine_driver_name(uint index)

  79. {

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

  81. 

  82.     return CarlaEngine::getDriverName(index);

  83. }

  84. 

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

  86. {

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

  88. 

  89.     return CarlaEngine::getDriverDeviceNames(index);

  90. }

  91. 

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

  93. {

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

  95. 

  96.     static EngineDriverDeviceInfo retDevInfo;

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

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

  99. 

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

  101. 

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

  103.     {

  104.         retDevInfo.hints       =  devInfo->hints;

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

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

  107.     }

  108.     else

  109.     {

  110.         retDevInfo.hints       = 0x0;

  111.         retDevInfo.bufferSizes = nullBufferSizes;

  112.         retDevInfo.sampleRates = nullSampleRates;

  113.     }

  114. 

  115.     return &retDevInfo;

  116. }

  117. 

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

  119. {

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

  121. }

  122. 

  123. // --------------------------------------------------------------------------------------------------------------------

  124. 

  125. CarlaHostHandle carla_standalone_host_init(void)

  126. {

  127. #ifdef CARLA_OS_UNIX

  128.     static const ThreadSafeFFTW sThreadSafeFFTW;

  129. #endif

  130. 

  131.     static CarlaHostStandalone gStandalone;

  132. 

  133.     return &gStandalone;

  134. }

  135. 

  136. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  137. {

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

  139. 

  140.     return handle->engine;

  141. }

  142. 

  143. // --------------------------------------------------------------------------------------------------------------------

  144. 

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

  146. {

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

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

  149. 

  150.     using water::File;

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

  152. 

  153. #ifdef BUILD_BRIDGE

  154.     /*

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

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

  157. 

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

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

  160. 

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

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

  163.     */

  164. 

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

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

  167. 

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

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

  170. 

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

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

  173. 

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

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

  176. 

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

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

  179. 

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

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

  182. 

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

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

  185. 

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

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

  188. 

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

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

  191. 

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

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

  194. 

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

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

  197. 

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

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

  200. 

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

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

  203. 

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

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

  206.     else

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

  208. 

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

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

  211.     else

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

  213. 

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

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

  216. 

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

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

  219. #else

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

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

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

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

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

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

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

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

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

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

  230. 

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

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

  233. 

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

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

  236. 

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

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

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

  240. 

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

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

  243. 

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

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

  246. 

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

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

  249. 

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

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

  252. 

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

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

  255. 

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

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

  258. 

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

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

  261. 

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

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

  264. 

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

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

  267. 

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

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

  270.     else

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

  272. 

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

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

  275. 

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

  277. 

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

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

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

  281. 

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

  283.     {

  284.         char strBuf[STR_MAX+1];

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

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

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

  288.     }

  289.     else

  290.     {

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

  292.     }

  293. 

  294. # ifndef CARLA_OS_WIN

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

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

  297. 

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

  299. 

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

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

  302. 

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

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

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

  306. # endif

  307. #endif

  308. }

  309. 

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

  311. {

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

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

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

  315. 

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

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

  318. 

  319. #ifdef CARLA_OS_WIN

  320.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  321. #endif

  322. 

  323. #ifdef USING_JUCE

  324.     juce::initialiseJuce_GUI();

  325. #if !(defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN))

  326.     juce::MessageManager::getInstance()->setCurrentThreadAsMessageThread();

  327. #endif

  328. #endif

  329. 

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

  331. 

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

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

  334. 

  335.     shandle.engine = engine;

  336. 

  337. #ifdef BUILD_BRIDGE

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

  339.     {

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

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

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

  343. 

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

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

  346.     }

  347.     else

  348.     {

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

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

  351.     }

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

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

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

  355. #else

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

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

  358. #endif

  359. 

  360.     carla_engine_init_common(shandle, engine);

  361. 

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

  363.     {

  364. #ifndef BUILD_BRIDGE

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

  366.             shandle.logThread.init();

  367. #endif

  368.         shandle.lastError = "No error";

  369.         return true;

  370.     }

  371.     else

  372.     {

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

  374.         shandle.engine = nullptr;

  375.         delete engine;

  376. #ifdef USING_JUCE

  377.         juce::shutdownJuce_GUI();

  378. #endif

  379.         return false;

  380.     }

  381. }

  382. 

  383. #ifdef BUILD_BRIDGE

  384. bool carla_engine_init_bridge(CarlaHostHandle handle,

  385.                               const char audioBaseName[6+1],

  386.                               const char rtClientBaseName[6+1],

  387.                               const char nonRtClientBaseName[6+1],

  388.                               const char nonRtServerBaseName[6+1],

  389.                               const char* const clientName)

  390. {

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

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

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

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

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

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

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

  398. 

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

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

  401. 

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

  403.                                                                      rtClientBaseName,

  404.                                                                      nonRtClientBaseName,

  405.                                                                      nonRtServerBaseName));

  406. 

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

  408. 

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

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

  411. 

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

  413. 

  414.     carla_engine_init_common(shandle, engine);

  415. 

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

  417.     {

  418.         shandle.lastError = "No error";

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

  420.         return true;

  421.     }

  422.     else

  423.     {

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

  425.         return false;

  426.     }

  427. }

  428. #endif

  429. 

  430. bool carla_engine_close(CarlaHostHandle handle)

  431. {

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

  433. 

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

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

  436. 

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

  438. 

  439.     CarlaEngine* const engine = shandle.engine;

  440. 

  441.     engine->setAboutToClose();

  442.     engine->removeAllPlugins();

  443. 

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

  445. 

  446.     if (! closed)

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

  448. 

  449. #ifndef BUILD_BRIDGE

  450.     shandle.logThread.stop();

  451. #endif

  452. 

  453.     shandle.engine = nullptr;

  454.     delete engine;

  455. 

  456. #ifdef USING_JUCE

  457.     juce::shutdownJuce_GUI();

  458. #endif

  459.     return closed;

  460. }

  461. 

  462. void carla_engine_idle(CarlaHostHandle handle)

  463. {

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

  465. 

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

  467. 

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

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

  470.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  471. 

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

  473. #endif

  474. }

  475. 

  476. bool carla_is_engine_running(CarlaHostHandle handle)

  477. {

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

  479. }

  480. 

  481. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  482. {

  483.     static CarlaRuntimeEngineInfo retInfo;

  484. 

  485.     // reset

  486.     retInfo.load = 0.0f;

  487.     retInfo.xruns = 0;

  488. 

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

  490. 

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

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

  493. 

  494.     return &retInfo;

  495. }

  496. 

  497. #ifndef BUILD_BRIDGE

  498. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  499. {

  500.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  501. 

  502.     // reset

  503.     retInfo.name = gNullCharPtr;

  504.     retInfo.hints = 0x0;

  505.     retInfo.bufferSize = 0;

  506.     retInfo.bufferSizes = nullptr;

  507.     retInfo.sampleRate = 0.0;

  508.     retInfo.sampleRates = nullptr;

  509. 

  510.     const char* audioDriver;

  511.     const char* audioDevice;

  512. 

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

  514.     {

  515.         audioDriver = engine->getCurrentDriverName();

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

  517. 

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

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

  520.     }

  521.     else if (handle->isStandalone)

  522.     {

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

  524. 

  525.         audioDriver = shandle.engineOptions.audioDriver;

  526.         audioDevice = shandle.engineOptions.audioDevice;

  527. 

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

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

  530.     }

  531.     else

  532.     {

  533.         return &retInfo;

  534.     }

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

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

  537. 

  538.     uint index = 0;

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

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

  541.     {

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

  543.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  544. 

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

  546.             break;

  547.     }

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

  549. 

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

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

  552. 

  553.     retInfo.name        = audioDevice;

  554.     retInfo.hints       = devInfo->hints;

  555.     retInfo.bufferSizes = devInfo->bufferSizes;

  556.     retInfo.sampleRates = devInfo->sampleRates;

  557. 

  558.     return &retInfo;

  559. }

  560. 

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

  562. {

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

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

  565. 

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

  567. }

  568. 

  569. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  570. {

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

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

  573. 

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

  575. }

  576. #endif // BUILD_BRIDGE

  577. 

  578. void carla_clear_engine_xruns(CarlaHostHandle handle)

  579. {

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

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

  582. }

  583. 

  584. void carla_cancel_engine_action(CarlaHostHandle handle)

  585. {

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

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

  588. }

  589. 

  590. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  591. {

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

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

  594. 

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

  596. }

  597. 

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

  599. {

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

  601. 

  602. #ifndef BUILD_BRIDGE

  603.     if (handle->isStandalone)

  604.     {

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

  606. 

  607.         shandle.engineCallback    = func;

  608.         shandle.engineCallbackPtr = ptr;

  609. 

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

  611.     }

  612. #endif

  613. 

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

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

  616. }

  617. 

  618. #ifndef BUILD_BRIDGE

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

  620. {

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

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

  623. 

  624.     if (handle->isStandalone)

  625.     {

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

  627. 

  628.         switch (option)

  629.         {

  630.         case CB::ENGINE_OPTION_DEBUG:

  631.             break;

  632. 

  633.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  636.             break;

  637. 

  638.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  640. 

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

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

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

  644.             {

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

  646. 

  647.                 if (shandle.engineCallback != nullptr)

  648.                     shandle.engineCallback(shandle.engineCallbackPtr,

  649.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  650.                                            0,

  651.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  652.                                            0, 0, 0.0f,

  653.                                            shandle.engineOptions.transportExtra);

  654.             }

  655.             else

  656.             {

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

  658.             }

  659. 

  660.             delete[] shandle.engineOptions.transportExtra;

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

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

  663.             else

  664.                 shandle.engineOptions.transportExtra = nullptr;

  665.             break;

  666. 

  667.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  670.             break;

  671. 

  672.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  675.             break;

  676. 

  677.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  680.             break;

  681. 

  682.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  685.             break;

  686. 

  687.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  688.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  690.             break;

  691. 

  692.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  695.             break;

  696. 

  697.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  698.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  700.             break;

  701. 

  702.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  703.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  705.             break;

  706. 

  707.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  708.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  710.             break;

  711. 

  712.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  715.             break;

  716. 

  717.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  718.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  719. 

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

  721.                 delete[] shandle.engineOptions.audioDriver;

  722. 

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

  724.             break;

  725. 

  726.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  727.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  728. 

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

  730.                 delete[] shandle.engineOptions.audioDevice;

  731. 

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

  733.             break;

  734. 

  735.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  738.             break;

  739. 

  740.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  742.             shandle.engineOptions.oscPortTCP = value;

  743.             break;

  744. 

  745.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  747.             shandle.engineOptions.oscPortUDP = value;

  748.             break;

  749. 

  750.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  753.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  754. 

  755.             switch (value)

  756.             {

  757.             case CB::FILE_AUDIO:

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

  759.                     delete[] shandle.engineOptions.pathAudio;

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

  761.                 break;

  762.             case CB::FILE_MIDI:

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

  764.                     delete[] shandle.engineOptions.pathMIDI;

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

  766.                 break;

  767.             }

  768.             break;

  769. 

  770.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  773.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  774. 

  775.             switch (value)

  776.             {

  777.             case CB::PLUGIN_LADSPA:

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

  779.                     delete[] shandle.engineOptions.pathLADSPA;

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

  781.                 break;

  782.             case CB::PLUGIN_DSSI:

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

  784.                     delete[] shandle.engineOptions.pathDSSI;

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

  786.                 break;

  787.             case CB::PLUGIN_LV2:

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

  789.                     delete[] shandle.engineOptions.pathLV2;

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

  791.                 break;

  792.             case CB::PLUGIN_VST2:

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

  794.                     delete[] shandle.engineOptions.pathVST2;

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

  796.                 break;

  797.             case CB::PLUGIN_VST3:

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

  799.                     delete[] shandle.engineOptions.pathVST3;

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

  801.                 break;

  802.             case CB::PLUGIN_SF2:

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

  804.                     delete[] shandle.engineOptions.pathSF2;

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

  806.                 break;

  807.             case CB::PLUGIN_SFZ:

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

  809.                     delete[] shandle.engineOptions.pathSFZ;

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

  811.                 break;

  812.             }

  813.             break;

  814. 

  815.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  817. 

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

  819.                 delete[] shandle.engineOptions.binaryDir;

  820. 

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

  822.             break;

  823. 

  824.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  826. 

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

  828.                 delete[] shandle.engineOptions.resourceDir;

  829. 

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

  831.             break;

  832. 

  833.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  836.             break;

  837. 

  838.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  840.             break;

  841. 

  842.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  844.             break;

  845. 

  846.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  847.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  849.             break;

  850. 

  851.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  854.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  856.         }   break;

  857. 

  858. # ifndef CARLA_OS_WIN

  859.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  861. 

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

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

  864. 

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

  866.             break;

  867. 

  868.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  871.             break;

  872. 

  873.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  875. 

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

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

  878. 

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

  880.             break;

  881. 

  882.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  885.             break;

  886. 

  887.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  890.             break;

  891. 

  892.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  895.             break;

  896. # endif // CARLA_OS_WIN

  897. 

  898.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  900.             break;

  901.         }

  902.     }

  903. 

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

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

  906. }

  907. #endif // BUILD_BRIDGE

  908. 

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

  910. {

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

  912. 

  913.     if (handle->isStandalone)

  914.     {

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

  916. 

  917.         shandle.fileCallback    = func;

  918.         shandle.fileCallbackPtr = ptr;

  919.     }

  920. 

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

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

  923. }

  924. 

  925. // --------------------------------------------------------------------------------------------------------------------

  926. 

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

  928. {

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

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

  931. 

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

  933. 

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

  935. }

  936. 

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

  938. {

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

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

  941. 

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

  943. 

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

  945. }

  946. 

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

  948. {

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

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

  951. 

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

  953. 

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

  955. }

  956. 

  957. #ifndef BUILD_BRIDGE

  958. void carla_clear_project_filename(CarlaHostHandle handle)

  959. {

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

  961. 

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

  963. 

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

  965. }

  966. 

  967. // --------------------------------------------------------------------------------------------------------------------

  968. 

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

  970. {

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

  972. 

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

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

  975. 

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

  977. }

  978. 

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

  980. {

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

  982. 

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

  984. 

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

  986. }

  987. 

  988. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  989. {

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

  991. 

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

  993. 

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

  995. }

  996. 

  997. // --------------------------------------------------------------------------------------------------------------------

  998. 

  999. void carla_transport_play(CarlaHostHandle handle)

  1000. {

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

  1002. 

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

  1004. 

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

  1006. }

  1007. 

  1008. void carla_transport_pause(CarlaHostHandle handle)

  1009. {

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

  1011. 

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

  1013. 

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

  1015. }

  1016. 

  1017. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1018. {

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

  1020. 

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

  1022. 

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

  1024. }

  1025. 

  1026. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1027. {

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

  1029. 

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

  1031. 

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

  1033. }

  1034. 

  1035. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1036. {

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

  1038. 

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

  1040. }

  1041. 

  1042. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1043. {

  1044.     static CarlaTransportInfo retTransInfo;

  1045.     retTransInfo.clear();

  1046. 

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

  1048. 

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

  1050. 

  1051.     retTransInfo.playing = timeInfo.playing;

  1052.     retTransInfo.frame   = timeInfo.frame;

  1053. 

  1054.     if (timeInfo.bbt.valid)

  1055.     {

  1056.         retTransInfo.bar  = timeInfo.bbt.bar;

  1057.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1060.     }

  1061. 

  1062.     return &retTransInfo;

  1063. }

  1064. #endif

  1065. 

  1066. // --------------------------------------------------------------------------------------------------------------------

  1067. 

  1068. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1069. {

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

  1071. 

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

  1073. 

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

  1075. }

  1076. 

  1077. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1078. {

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

  1080. 

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

  1082. 

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

  1084. }

  1085. 

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

  1087. 

  1088. bool carla_add_plugin(CarlaHostHandle handle,

  1089.                       BinaryType btype, PluginType ptype,

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

  1091.                       const void* extraPtr, uint options)

  1092. {

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

  1094. 

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

  1096.                 handle,

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

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

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

  1100. 

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

  1102. }

  1103. 

  1104. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1105. {

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

  1107. 

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

  1109. 

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

  1111. }

  1112. 

  1113. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1114. {

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

  1116. 

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

  1118. 

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

  1120. }

  1121. 

  1122. #ifndef BUILD_BRIDGE

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

  1124. {

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

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

  1127. 

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

  1129. 

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

  1131. }

  1132. 

  1133. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1134. {

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

  1136. 

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

  1138. 

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

  1140. }

  1141. 

  1142. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1143. {

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

  1145. 

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

  1147. 

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

  1149. }

  1150. 

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

  1152. {

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

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

  1155. 

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

  1157. 

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

  1159. }

  1160. #endif

  1161. 

  1162. // --------------------------------------------------------------------------------------------------------------------

  1163. 

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

  1165. {

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

  1167.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1169. 

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

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

  1172. 

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

  1174. 

  1175.     return plugin->loadStateFromFile(filename);

  1176. }

  1177. 

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

  1179. {

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

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

  1182. 

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

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

  1185. 

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

  1187. 

  1188.     return plugin->saveStateToFile(filename);

  1189. }

  1190. 

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

  1192. {

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

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

  1195. 

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

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

  1198. 

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

  1200. 

  1201.     return plugin->exportAsLV2(lv2path);

  1202. }

  1203. 

  1204. // --------------------------------------------------------------------------------------------------------------------

  1205. 

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

  1207. {

  1208.     static CarlaPluginInfo retInfo;

  1209. 

  1210.     // reset

  1211.     retInfo.type             = CB::PLUGIN_NONE;

  1212.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1213.     retInfo.hints            = 0x0;

  1214.     retInfo.optionsAvailable = 0x0;

  1215.     retInfo.optionsEnabled   = 0x0;

  1216.     retInfo.filename         = gNullCharPtr;

  1217.     retInfo.name             = gNullCharPtr;

  1218.     retInfo.iconName         = gNullCharPtr;

  1219.     retInfo.uniqueId         = 0;

  1220. 

  1221.     // cleanup

  1222.     if (retInfo.label != gNullCharPtr)

  1223.     {

  1224.         delete[] retInfo.label;

  1225.         retInfo.label = gNullCharPtr;

  1226.     }

  1227. 

  1228.     if (retInfo.maker != gNullCharPtr)

  1229.     {

  1230.         delete[] retInfo.maker;

  1231.         retInfo.maker = gNullCharPtr;

  1232.     }

  1233. 

  1234.     if (retInfo.copyright != gNullCharPtr)

  1235.     {

  1236.         delete[] retInfo.copyright;

  1237.         retInfo.copyright = gNullCharPtr;

  1238.     }

  1239. 

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

  1241. 

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

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

  1244. 

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

  1246. 

  1247.     char strBuf[STR_MAX+1];

  1248.     carla_zeroChars(strBuf, STR_MAX+1);

  1249. 

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

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

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

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

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

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

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

  1257. 

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

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

  1260. 

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

  1262.         retInfo.label = carla_strdup_safe(strBuf);

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

  1264.         retInfo.maker = carla_strdup_safe(strBuf);

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

  1266.         retInfo.copyright = carla_strdup_safe(strBuf);

  1267. 

  1268.     checkStringPtr(retInfo.filename);

  1269.     checkStringPtr(retInfo.name);

  1270.     checkStringPtr(retInfo.iconName);

  1271.     checkStringPtr(retInfo.label);

  1272.     checkStringPtr(retInfo.maker);

  1273.     checkStringPtr(retInfo.copyright);

  1274. 

  1275.     return &retInfo;

  1276. }

  1277. 

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

  1279. {

  1280.     static CarlaPortCountInfo retInfo;

  1281.     carla_zeroStruct(retInfo);

  1282. 

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

  1284. 

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

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

  1287. 

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

  1289. 

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

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

  1292.     return &retInfo;

  1293. }

  1294. 

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

  1296. {

  1297.     static CarlaPortCountInfo retInfo;

  1298.     carla_zeroStruct(retInfo);

  1299. 

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

  1301. 

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

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

  1304. 

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

  1306. 

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

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

  1309.     return &retInfo;

  1310. }

  1311. 

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

  1313. {

  1314.     static CarlaPortCountInfo retInfo;

  1315.     carla_zeroStruct(retInfo);

  1316. 

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

  1318. 

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

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

  1321. 

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

  1323. 

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

  1325.     return &retInfo;

  1326. }

  1327. 

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

  1329. {

  1330.     static CarlaParameterInfo retInfo(gNullCharPtr);

  1331. 

  1332.     // reset

  1333.     retInfo.scalePointCount = 0;

  1334. 

  1335.     // cleanup

  1336.     if (retInfo.name != gNullCharPtr)

  1337.     {

  1338.         delete[] retInfo.name;

  1339.         retInfo.name = gNullCharPtr;

  1340.     }

  1341. 

  1342.     if (retInfo.symbol != gNullCharPtr)

  1343.     {

  1344.         delete[] retInfo.symbol;

  1345.         retInfo.symbol = gNullCharPtr;

  1346.     }

  1347. 

  1348.     if (retInfo.unit != gNullCharPtr)

  1349.     {

  1350.         delete[] retInfo.unit;

  1351.         retInfo.unit = gNullCharPtr;

  1352.     }

  1353. 

  1354.     if (retInfo.comment != gNullCharPtr)

  1355.     {

  1356.         delete[] retInfo.comment;

  1357.         retInfo.comment = gNullCharPtr;

  1358.     }

  1359. 

  1360.     if (retInfo.groupName != gNullCharPtr)

  1361.     {

  1362.         delete[] retInfo.groupName;

  1363.         retInfo.groupName = gNullCharPtr;

  1364.     }

  1365. 

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

  1367. 

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

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

  1370. 

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

  1372. 

  1373.     char strBuf[STR_MAX+1];

  1374.     carla_zeroChars(strBuf, STR_MAX+1);

  1375. 

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

  1377. 

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

  1379.     {

  1380.         retInfo.name = carla_strdup_safe(strBuf);

  1381.         carla_zeroChars(strBuf, STR_MAX+1);

  1382.     }

  1383. 

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

  1385.     {

  1386.         retInfo.symbol = carla_strdup_safe(strBuf);

  1387.         carla_zeroChars(strBuf, STR_MAX+1);

  1388.     }

  1389. 

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

  1391.     {

  1392.         retInfo.unit = carla_strdup_safe(strBuf);

  1393.         carla_zeroChars(strBuf, STR_MAX+1);

  1394.     }

  1395. 

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

  1397.     {

  1398.         retInfo.comment = carla_strdup_safe(strBuf);

  1399.         carla_zeroChars(strBuf, STR_MAX+1);

  1400.     }

  1401. 

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

  1403.     {

  1404.         retInfo.groupName = carla_strdup_safe(strBuf);

  1405.         carla_zeroChars(strBuf, STR_MAX+1);

  1406.     }

  1407. 

  1408.     checkStringPtr(retInfo.name);

  1409.     checkStringPtr(retInfo.symbol);

  1410.     checkStringPtr(retInfo.unit);

  1411.     checkStringPtr(retInfo.comment);

  1412.     checkStringPtr(retInfo.groupName);

  1413. 

  1414.     return &retInfo;

  1415. }

  1416. 

  1417. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1418.                                                                uint pluginId,

  1419.                                                                uint32_t parameterId,

  1420.                                                                uint32_t scalePointId)

  1421. {

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

  1423. 

  1424.     static CarlaScalePointInfo retInfo;

  1425. 

  1426.     // reset

  1427.     retInfo.value = 0.0f;

  1428. 

  1429.     // cleanup

  1430.     if (retInfo.label != gNullCharPtr)

  1431.     {

  1432.         delete[] retInfo.label;

  1433.         retInfo.label = gNullCharPtr;

  1434.     }

  1435. 

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

  1437. 

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

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

  1440. 

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

  1442. 

  1443.     char strBuf[STR_MAX+1];

  1444. 

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

  1446. 

  1447.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1449.         retInfo.label = carla_strdup_safe(strBuf);

  1450. 

  1451.     checkStringPtr(retInfo.label);

  1452. 

  1453.     return &retInfo;

  1454. }

  1455. 

  1456. // --------------------------------------------------------------------------------------------------------------------

  1457. 

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

  1459. {

  1460.     static ParameterData retParamData;

  1461. 

  1462.     // reset

  1463.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1464.     retParamData.hints       = 0x0;

  1465.     retParamData.index       = CB::PARAMETER_NULL;

  1466.     retParamData.rindex      = -1;

  1467.     retParamData.midiChannel = 0;

  1468.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1469.     retParamData.mappedMinimum = 0.0f;

  1470.     retParamData.mappedMaximum = 0.0f;

  1471. 

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

  1473. 

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

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

  1476. 

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

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

  1479. 

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

  1481.     retParamData.type        = pluginParamData.type;

  1482.     retParamData.hints       = pluginParamData.hints;

  1483.     retParamData.index       = pluginParamData.index;

  1484.     retParamData.rindex      = pluginParamData.rindex;

  1485.     retParamData.midiChannel = pluginParamData.midiChannel;

  1486.     retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1487.     retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1488.     retParamData.mappedMaximum = pluginParamData.mappedMaximum;

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

  1490. }

  1491. 

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

  1493. {

  1494.     static ParameterRanges retParamRanges;

  1495. 

  1496.     // reset

  1497.     retParamRanges.def       = 0.0f;

  1498.     retParamRanges.min       = 0.0f;

  1499.     retParamRanges.max       = 1.0f;

  1500.     retParamRanges.step      = 0.01f;

  1501.     retParamRanges.stepSmall = 0.0001f;

  1502.     retParamRanges.stepLarge = 0.1f;

  1503. 

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

  1505. 

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

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

  1508. 

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

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

  1511. 

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

  1513.     retParamRanges.def       = pluginParamRanges.def;

  1514.     retParamRanges.min       = pluginParamRanges.min;

  1515.     retParamRanges.max       = pluginParamRanges.max;

  1516.     retParamRanges.step      = pluginParamRanges.step;

  1517.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1518.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1519.     return &pluginParamRanges;

  1520. }

  1521. 

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

  1523. {

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

  1525. 

  1526.     // reset

  1527.     retMidiProgData.bank    = 0;

  1528.     retMidiProgData.program = 0;

  1529. 

  1530.     if (retMidiProgData.name != gNullCharPtr)

  1531.     {

  1532.         delete[] retMidiProgData.name;

  1533.         retMidiProgData.name = gNullCharPtr;

  1534.     }

  1535. 

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

  1537. 

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

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

  1540. 

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

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

  1543. 

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

  1545.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1546.     retMidiProgData.program = pluginMidiProgData.program;

  1547. 

  1548.     if (pluginMidiProgData.name != nullptr)

  1549.     {

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

  1551.         checkStringPtr(retMidiProgData.name);

  1552.     }

  1553.     else

  1554.     {

  1555.         retMidiProgData.name = gNullCharPtr;

  1556.     }

  1557. 

  1558.     return &retMidiProgData;

  1559. }

  1560. 

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

  1562. {

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

  1564. 

  1565.     // reset

  1566.     if (retCustomData.type != gNullCharPtr)

  1567.     {

  1568.         delete[] retCustomData.type;

  1569.         retCustomData.type = gNullCharPtr;

  1570.     }

  1571. 

  1572.     if (retCustomData.key != gNullCharPtr)

  1573.     {

  1574.         delete[] retCustomData.key;

  1575.         retCustomData.key = gNullCharPtr;

  1576.     }

  1577. 

  1578.     if (retCustomData.value != gNullCharPtr)

  1579.     {

  1580.         delete[] retCustomData.value;

  1581.         retCustomData.value = gNullCharPtr;

  1582.     }

  1583. 

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

  1585. 

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

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

  1588. 

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

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

  1591. 

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

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

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

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

  1596.     checkStringPtr(retCustomData.type);

  1597.     checkStringPtr(retCustomData.key);

  1598.     checkStringPtr(retCustomData.value);

  1599.     return &retCustomData;

  1600. }

  1601. 

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

  1603. {

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

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

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

  1607. 

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

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

  1610. 

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

  1612. 

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

  1614. 

  1615.     if (count == 0)

  1616.         return gNullCharPtr;

  1617. 

  1618.     static CarlaString customDataValue;

  1619. 

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

  1621.     {

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

  1623. 

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

  1625.             continue;

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

  1627.             continue;

  1628. 

  1629.         customDataValue = pluginCustomData.value;

  1630.         return customDataValue.buffer();

  1631.     }

  1632. 

  1633.     return gNullCharPtr;

  1634. }

  1635. 

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

  1637. {

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

  1639. 

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

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

  1642. 

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

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

  1645. 

  1646.     void* data = nullptr;

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

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

  1649. 

  1650.     static CarlaString chunkData;

  1651. 

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

  1653.     return chunkData.buffer();

  1654. }

  1655. 

  1656. // --------------------------------------------------------------------------------------------------------------------

  1657. 

  1658. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1659. {

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

  1661. 

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

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

  1664. 

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

  1666.     return plugin->getParameterCount();

  1667. }

  1668. 

  1669. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1670. {

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

  1672. 

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

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

  1675. 

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

  1677.     return plugin->getProgramCount();

  1678. }

  1679. 

  1680. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1681. {

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

  1683. 

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

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

  1686. 

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

  1688.     return plugin->getMidiProgramCount();

  1689. }

  1690. 

  1691. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1692. {

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

  1694. 

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

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

  1697. 

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

  1699.     return plugin->getCustomDataCount();

  1700. }

  1701. 

  1702. // --------------------------------------------------------------------------------------------------------------------

  1703. 

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

  1705. {

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

  1707. 

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

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

  1710. 

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

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

  1713. 

  1714.     static char textBuf[STR_MAX+1];

  1715.     carla_zeroChars(textBuf, STR_MAX+1);

  1716. 

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

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

  1719. 

  1720.     return textBuf;

  1721. }

  1722. 

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

  1724. {

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

  1726. 

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

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

  1729. 

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

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

  1732. 

  1733.     static char programName[STR_MAX+1];

  1734.     carla_zeroChars(programName, STR_MAX+1);

  1735. 

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

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

  1738. 

  1739.     return programName;

  1740. }

  1741. 

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

  1743. {

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

  1745. 

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

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

  1748. 

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

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

  1751. 

  1752.     static char midiProgramName[STR_MAX+1];

  1753.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1754. 

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

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

  1757. 

  1758.     return midiProgramName;

  1759. }

  1760. 

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

  1762. {

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

  1764. 

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

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

  1767. 

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

  1769.     static char realPluginName[STR_MAX+1];

  1770.     carla_zeroChars(realPluginName, STR_MAX+1);

  1771. 

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

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

  1774. 

  1775.     return realPluginName;

  1776. }

  1777. 

  1778. // --------------------------------------------------------------------------------------------------------------------

  1779. 

  1780. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1781. {

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

  1783. 

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

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

  1786. 

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

  1788.     return plugin->getCurrentProgram();

  1789. }

  1790. 

  1791. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1792. {

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

  1794. 

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

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

  1797. 

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

  1799.     return plugin->getCurrentMidiProgram();

  1800. }

  1801. 

  1802. // --------------------------------------------------------------------------------------------------------------------

  1803. 

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

  1805. {

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

  1807. 

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

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

  1810. 

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

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

  1813. 

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

  1815. }

  1816. 

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

  1818. {

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

  1820. 

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

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

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

  1824. 

  1825.     return plugin->getParameterValue(parameterId);

  1826. }

  1827. 

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

  1829. {

  1830. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1832. #else

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

  1834. #endif

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

  1836. 

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

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

  1839. 

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

  1841.     return plugin->getInternalParameterValue(parameterId);

  1842. }

  1843. 

  1844. // --------------------------------------------------------------------------------------------------------------------

  1845. 

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

  1847. {

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

  1849. 

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

  1851. }

  1852. 

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

  1854. {

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

  1856. 

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

  1858. }

  1859. 

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

  1861. {

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

  1863. 

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

  1865. }

  1866. 

  1867. // --------------------------------------------------------------------------------------------------------------------

  1868. 

  1869. CARLA_BACKEND_START_NAMESPACE

  1870. 

  1871. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1872. // defined in CarlaPluginInternal.cpp

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

  1874. #endif

  1875. 

  1876. // defined in CarlaPluginLV2.cpp

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

  1878. 

  1879. CARLA_BACKEND_END_NAMESPACE

  1880. 

  1881. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  1882.                                                                   uint pluginId,

  1883.                                                                   uint32_t width, uint32_t height)

  1884. {

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

  1886. 

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

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

  1889. 

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

  1891. 

  1892.     switch (plugin->getType())

  1893.     {

  1894. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1895.     case CB::PLUGIN_INTERNAL:

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

  1897. #endif

  1898.     case CB::PLUGIN_LV2:

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

  1900.     default:

  1901.         return nullptr;

  1902.     }

  1903. }

  1904. 

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

  1906. 

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

  1908. {

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

  1910. 

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

  1912.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1913. 

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

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

  1916. }

  1917. 

  1918. #ifndef BUILD_BRIDGE

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

  1920. {

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

  1922. 

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

  1924.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1925. 

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

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

  1928. }

  1929. 

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

  1931. {

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

  1933. 

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

  1935.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1936. 

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

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

  1939. }

  1940. 

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

  1942. {

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

  1944. 

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

  1946.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1947. 

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

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

  1950. }

  1951. 

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

  1953. {

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

  1955. 

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

  1957.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1958. 

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

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

  1961. }

  1962. 

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

  1964. {

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

  1966. 

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

  1968.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1969. 

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

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

  1972. }

  1973. 

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

  1975. {

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

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

  1978. 

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

  1980.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1981. 

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

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

  1984. }

  1985. #endif

  1986. 

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

  1988. {

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

  1990. 

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

  1992.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1993. 

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

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

  1996. }

  1997. 

  1998. // --------------------------------------------------------------------------------------------------------------------

  1999. 

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

  2001. {

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

  2003. 

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

  2005.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2006. 

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

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

  2009. 

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

  2011. }

  2012. 

  2013. #ifndef BUILD_BRIDGE

  2014. 

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

  2016. {

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

  2018.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2019. 

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

  2021.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2022. 

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

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

  2025. 

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

  2027. }

  2028. 

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

  2030. {

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

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

  2033. 

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

  2035.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2036. 

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

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

  2039. 

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

  2041. }

  2042. 

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

  2044. {

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

  2046. 

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

  2048.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2049. 

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

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

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

  2053. 

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

  2055. }

  2056. 

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

  2058. {

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

  2060. 

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

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

  2063. }

  2064. #endif

  2065. 

  2066. // --------------------------------------------------------------------------------------------------------------------

  2067. 

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

  2069. {

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

  2071. 

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

  2073.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2074. 

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

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

  2077. 

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

  2079. }

  2080. 

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

  2082. {

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

  2084. 

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

  2086.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2087. 

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

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

  2090. 

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

  2092. }

  2093. 

  2094. // --------------------------------------------------------------------------------------------------------------------

  2095. 

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

  2097. {

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

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

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

  2101.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2102. 

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

  2104.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2105. 

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

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

  2108. }

  2109. 

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

  2111. {

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

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

  2114. 

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

  2116.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2117. 

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

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

  2120. 

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

  2122. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2124. #else

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

  2126. #endif

  2127. }

  2128. 

  2129. // --------------------------------------------------------------------------------------------------------------------

  2130. 

  2131. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2132. {

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

  2134. 

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

  2136.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2137. 

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

  2139.     return plugin->prepareForSave();

  2140. }

  2141. 

  2142. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2143. {

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

  2145. 

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

  2147.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2148. 

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

  2150.     return plugin->resetParameters();

  2151. }

  2152. 

  2153. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2154. {

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

  2156. 

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

  2158.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2159. 

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

  2161.     return plugin->randomizeParameters();

  2162. }

  2163. 

  2164. #ifndef BUILD_BRIDGE

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

  2166. {

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

  2168. 

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

  2170.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2171. 

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

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

  2174. }

  2175. #endif

  2176. 

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

  2178. {

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

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

  2181. 

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

  2183.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2184. 

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

  2186.     return plugin->setCustomUiTitleFormat(format);

  2187. }

  2188. 

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

  2190. {

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

  2192. 

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

  2194.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2195. 

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

  2197.     return plugin->showCustomUI(yesNo);

  2198. }

  2199. 

  2200. // --------------------------------------------------------------------------------------------------------------------

  2201. 

  2202. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2203. {

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

  2205. 

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

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

  2208. }

  2209. 

  2210. double carla_get_sample_rate(CarlaHostHandle handle)

  2211. {

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

  2213. 

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

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

  2216. }

  2217. 

  2218. // --------------------------------------------------------------------------------------------------------------------

  2219. 

  2220. const char* carla_get_last_error(CarlaHostHandle handle)

  2221. {

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

  2223. 

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

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

  2226. 

  2227.     return handle->isStandalone

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

  2229.            : gNullCharPtr;

  2230. }

  2231. 

  2232. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2233. {

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

  2235. 

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

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

  2238.     {

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

  2240.         if (handle->isStandalone)

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

  2242.         return gNullCharPtr;

  2243.     }

  2244. 

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

  2246. 

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

  2248.         return path;

  2249. 

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

  2251.     return notAvailable;

  2252. #else

  2253.     return gNullCharPtr;

  2254. 

  2255.     // unused

  2256.     (void)handle;

  2257. #endif

  2258. }

  2259. 

  2260. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2261. {

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

  2263. 

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

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

  2266.     {

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

  2268.         if (handle->isStandalone)

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

  2270.         return gNullCharPtr;

  2271.     }

  2272. 

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

  2274. 

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

  2276.         return path;

  2277. 

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

  2279.     return notAvailable;

  2280. #else

  2281.     return gNullCharPtr;

  2282. 

  2283.     // unused

  2284.     (void)handle;

  2285. #endif

  2286. }

  2287. 

  2288. // --------------------------------------------------------------------------------------------------------------------

  2289. 

  2290. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2291. #include "CarlaPluginUI.cpp"

  2292. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2293. 

  2294. #include "CarlaDssiUtils.cpp"

  2295. #include "CarlaMacUtils.cpp"

  2296. #include "CarlaPatchbayUtils.cpp"

  2297. #include "CarlaPipeUtils.cpp"

  2298. #include "CarlaStateUtils.cpp"

  2299. 

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