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

2237 lines
80KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHostImpl.hpp"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngineInit.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #ifdef BUILD_BRIDGE

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

  33. #else

  34. # include "CarlaLogThread.hpp"

  35. #endif

  36. 

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

  38.     if (! (cond)) {                                              \

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

  40.         if (handle->isStandalone)                                \

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

  42.         return ret;                                              \

  43.     }

  44. 

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

  46. // API

  47. 

  48. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  49. #include "CarlaHostCommon.cpp"

  50. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  51. 

  52. #ifdef USING_JUCE

  53. static void carla_juce_init();

  54. static void carla_juce_idle();

  55. static void carla_juce_cleanup();

  56. # include "utils/JUCE.cpp"

  57. #endif

  58. 

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

  60. 

  61. using CarlaBackend::CarlaPluginPtr;

  62. 

  63. // --------------------------------------------------------------------------------------------------------------------

  64. 

  65. uint carla_get_engine_driver_count()

  66. {

  67.     carla_debug("carla_get_engine_driver_count()");

  68. 

  69.     return CarlaEngine::getDriverCount();

  70. }

  71. 

  72. const char* carla_get_engine_driver_name(uint index)

  73. {

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

  75. 

  76.     return CarlaEngine::getDriverName(index);

  77. }

  78. 

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

  80. {

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

  82. 

  83.     return CarlaEngine::getDriverDeviceNames(index);

  84. }

  85. 

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

  87. {

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

  89. 

  90.     static EngineDriverDeviceInfo retDevInfo;

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

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

  93. 

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

  95. 

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

  97.     {

  98.         retDevInfo.hints       =  devInfo->hints;

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

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

  101.     }

  102.     else

  103.     {

  104.         retDevInfo.hints       = 0x0;

  105.         retDevInfo.bufferSizes = nullBufferSizes;

  106.         retDevInfo.sampleRates = nullSampleRates;

  107.     }

  108. 

  109.     return &retDevInfo;

  110. }

  111. 

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

  113. {

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

  115. }

  116. 

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

  118. 

  119. CarlaHostHandle carla_standalone_host_init(void)

  120. {

  121. #ifdef CARLA_OS_UNIX

  122.     static const ThreadSafeFFTW sThreadSafeFFTW;

  123. #endif

  124. 

  125.     static CarlaHostStandalone gStandalone;

  126. 

  127.     return &gStandalone;

  128. }

  129. 

  130. CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle)

  131. {

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

  133. 

  134.     return handle->engine;

  135. }

  136. 

  137. // --------------------------------------------------------------------------------------------------------------------

  138. 

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

  140. {

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

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

  143. 

  144.     using water::File;

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

  146. 

  147. #ifdef BUILD_BRIDGE

  148.     /*

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

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

  151. 

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

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

  154. 

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

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

  157.     */

  158. 

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

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

  161. 

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

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

  164. 

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

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

  167. 

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

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

  170. 

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

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

  173. 

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

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

  176. 

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

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

  179. 

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

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

  182. 

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

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

  185. 

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

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

  188. 

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

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

  191. 

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

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

  194. 

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

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

  197. 

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

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

  200.     else

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

  202. 

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

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

  205.     else

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

  207. 

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

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

  210. 

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

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

  213. #else

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

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

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

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

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

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

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

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

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

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

  224. 

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

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

  227. 

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

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

  230. 

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

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

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

  234. 

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

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

  237. 

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

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

  240. 

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

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

  243. 

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

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

  246. 

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

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

  249. 

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

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

  252. 

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

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

  255. 

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

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

  258. 

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

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

  261. 

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

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

  264.     else

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

  266. 

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

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

  269. 

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

  271. 

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

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

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

  275. 

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

  277.     {

  278.         char strBuf[STR_MAX+1];

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

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

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

  282.     }

  283.     else

  284.     {

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

  286.     }

  287. 

  288. # ifndef CARLA_OS_WIN

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

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

  291. 

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

  293. 

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

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

  296. 

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

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

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

  300. # endif

  301. #endif

  302. }

  303. 

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

  305. {

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

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

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

  309. 

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

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

  312. 

  313. #ifdef CARLA_OS_WIN

  314.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  315. #endif

  316. 

  317. #ifdef USING_JUCE

  318.     carla_juce_init();

  319. #endif

  320. 

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

  322. 

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

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

  325. 

  326.     shandle.engine = engine;

  327. 

  328. #ifdef BUILD_BRIDGE

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

  330.     {

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

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

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

  334. 

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

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

  337.     }

  338.     else

  339.     {

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

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

  342.     }

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

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

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

  346. #else

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

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

  349. #endif

  350. 

  351.     carla_engine_init_common(shandle, engine);

  352. 

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

  354.     {

  355. #ifndef BUILD_BRIDGE

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

  357.             shandle.logThread.init();

  358. #endif

  359.         shandle.lastError = "No error";

  360.         return true;

  361.     }

  362.     else

  363.     {

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

  365.         shandle.engine = nullptr;

  366.         delete engine;

  367. #ifdef USING_JUCE

  368.         carla_juce_cleanup();

  369. #endif

  370.         return false;

  371.     }

  372. }

  373. 

  374. #ifdef BUILD_BRIDGE

  375. bool carla_engine_init_bridge(CarlaHostHandle handle,

  376.                               const char audioBaseName[6+1],

  377.                               const char rtClientBaseName[6+1],

  378.                               const char nonRtClientBaseName[6+1],

  379.                               const char nonRtServerBaseName[6+1],

  380.                               const char* const clientName)

  381. {

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

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

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

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

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

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

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

  389. 

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

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

  392. 

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

  394.                                                                      rtClientBaseName,

  395.                                                                      nonRtClientBaseName,

  396.                                                                      nonRtServerBaseName));

  397. 

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

  399. 

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

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

  402. 

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

  404. 

  405.     carla_engine_init_common(shandle, engine);

  406. 

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

  408.     {

  409.         shandle.lastError = "No error";

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

  411.         return true;

  412.     }

  413.     else

  414.     {

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

  416.         return false;

  417.     }

  418. }

  419. #endif

  420. 

  421. bool carla_engine_close(CarlaHostHandle handle)

  422. {

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

  424. 

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

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

  427. 

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

  429. 

  430.     CarlaEngine* const engine = shandle.engine;

  431. 

  432.     engine->setAboutToClose();

  433.     engine->removeAllPlugins();

  434. 

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

  436. 

  437.     if (! closed)

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

  439. 

  440. #ifndef BUILD_BRIDGE

  441.     shandle.logThread.stop();

  442. #endif

  443. 

  444.     shandle.engine = nullptr;

  445.     delete engine;

  446. 

  447. #ifdef USING_JUCE

  448.     carla_juce_cleanup();

  449. #endif

  450.     return closed;

  451. }

  452. 

  453. void carla_engine_idle(CarlaHostHandle handle)

  454. {

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

  456. 

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

  458. 

  459. #ifdef USING_JUCE

  460.     if (handle->isStandalone)

  461.         carla_juce_idle();

  462. #endif

  463. }

  464. 

  465. bool carla_is_engine_running(CarlaHostHandle handle)

  466. {

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

  468. }

  469. 

  470. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle)

  471. {

  472.     static CarlaRuntimeEngineInfo retInfo;

  473. 

  474.     // reset

  475.     retInfo.load = 0.0f;

  476.     retInfo.xruns = 0;

  477. 

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

  479. 

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

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

  482. 

  483.     return &retInfo;

  484. }

  485. 

  486. #ifndef BUILD_BRIDGE

  487. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle)

  488. {

  489.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  490. 

  491.     // reset

  492.     retInfo.name = gNullCharPtr;

  493.     retInfo.hints = 0x0;

  494.     retInfo.bufferSize = 0;

  495.     retInfo.bufferSizes = nullptr;

  496.     retInfo.sampleRate = 0.0;

  497.     retInfo.sampleRates = nullptr;

  498. 

  499.     const char* audioDriver;

  500.     const char* audioDevice;

  501. 

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

  503.     {

  504.         audioDriver = engine->getCurrentDriverName();

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

  506. 

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

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

  509.     }

  510.     else if (handle->isStandalone)

  511.     {

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

  513. 

  514.         audioDriver = shandle.engineOptions.audioDriver;

  515.         audioDevice = shandle.engineOptions.audioDevice;

  516. 

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

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

  519.     }

  520.     else

  521.     {

  522.         return &retInfo;

  523.     }

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

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

  526. 

  527.     uint index = 0;

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

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

  530.     {

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

  532.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  533. 

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

  535.             break;

  536.     }

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

  538. 

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

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

  541. 

  542.     retInfo.name        = audioDevice;

  543.     retInfo.hints       = devInfo->hints;

  544.     retInfo.bufferSizes = devInfo->bufferSizes;

  545.     retInfo.sampleRates = devInfo->sampleRates;

  546. 

  547.     return &retInfo;

  548. }

  549. 

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

  551. {

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

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

  554. 

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

  556. }

  557. 

  558. bool carla_show_engine_device_control_panel(CarlaHostHandle handle)

  559. {

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

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

  562. 

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

  564. }

  565. #endif // BUILD_BRIDGE

  566. 

  567. void carla_clear_engine_xruns(CarlaHostHandle handle)

  568. {

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

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

  571. }

  572. 

  573. void carla_cancel_engine_action(CarlaHostHandle handle)

  574. {

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

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

  577. }

  578. 

  579. bool carla_set_engine_about_to_close(CarlaHostHandle handle)

  580. {

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

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

  583. 

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

  585. }

  586. 

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

  588. {

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

  590. 

  591.     if (handle->isStandalone)

  592.     {

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

  594. 

  595.         shandle.engineCallback    = func;

  596.         shandle.engineCallbackPtr = ptr;

  597. 

  598. #ifndef BUILD_BRIDGE

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

  600. #endif

  601.     }

  602. 

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

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

  605. }

  606. 

  607. #ifndef BUILD_BRIDGE

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

  609. {

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

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

  612. 

  613.     if (handle->isStandalone)

  614.     {

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

  616. 

  617.         switch (option)

  618.         {

  619.         case CB::ENGINE_OPTION_DEBUG:

  620.             break;

  621. 

  622.         case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  625.             break;

  626. 

  627.         case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  629. 

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

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

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

  633.             {

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

  635. 

  636.                 if (shandle.engineCallback != nullptr)

  637.                     shandle.engineCallback(shandle.engineCallbackPtr,

  638.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  639.                                            0,

  640.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  641.                                            0, 0, 0.0f,

  642.                                            shandle.engineOptions.transportExtra);

  643.             }

  644.             else

  645.             {

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

  647.             }

  648. 

  649.             delete[] shandle.engineOptions.transportExtra;

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

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

  652.             else

  653.                 shandle.engineOptions.transportExtra = nullptr;

  654.             break;

  655. 

  656.         case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  659.             break;

  660. 

  661.         case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  664.             break;

  665. 

  666.         case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  669.             break;

  670. 

  671.         case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  674.             break;

  675. 

  676.         case CB::ENGINE_OPTION_MAX_PARAMETERS:

  677.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  679.             break;

  680. 

  681.         case CB::ENGINE_OPTION_RESET_XRUNS:

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

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

  684.             break;

  685. 

  686.         case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  687.             CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  689.             break;

  690. 

  691.         case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  692.             CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  694.             break;

  695. 

  696.         case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  697.             CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  699.             break;

  700. 

  701.         case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  704.             break;

  705. 

  706.         case CB::ENGINE_OPTION_AUDIO_DRIVER:

  707.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  708. 

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

  710.                 delete[] shandle.engineOptions.audioDriver;

  711. 

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

  713.             break;

  714. 

  715.         case CB::ENGINE_OPTION_AUDIO_DEVICE:

  716.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  717. 

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

  719.                 delete[] shandle.engineOptions.audioDevice;

  720. 

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

  722.             break;

  723. 

  724.         case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  727.             break;

  728. 

  729.         case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  731.             shandle.engineOptions.oscPortTCP = value;

  732.             break;

  733. 

  734.         case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  736.             shandle.engineOptions.oscPortUDP = value;

  737.             break;

  738. 

  739.         case CB::ENGINE_OPTION_FILE_PATH:

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

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

  742.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  743. 

  744.             switch (value)

  745.             {

  746.             case CB::FILE_AUDIO:

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

  748.                     delete[] shandle.engineOptions.pathAudio;

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

  750.                 break;

  751.             case CB::FILE_MIDI:

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

  753.                     delete[] shandle.engineOptions.pathMIDI;

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

  755.                 break;

  756.             }

  757.             break;

  758. 

  759.         case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  762.             CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  763. 

  764.             switch (value)

  765.             {

  766.             case CB::PLUGIN_LADSPA:

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

  768.                     delete[] shandle.engineOptions.pathLADSPA;

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

  770.                 break;

  771.             case CB::PLUGIN_DSSI:

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

  773.                     delete[] shandle.engineOptions.pathDSSI;

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

  775.                 break;

  776.             case CB::PLUGIN_LV2:

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

  778.                     delete[] shandle.engineOptions.pathLV2;

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

  780.                 break;

  781.             case CB::PLUGIN_VST2:

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

  783.                     delete[] shandle.engineOptions.pathVST2;

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

  785.                 break;

  786.             case CB::PLUGIN_VST3:

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

  788.                     delete[] shandle.engineOptions.pathVST3;

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

  790.                 break;

  791.             case CB::PLUGIN_SF2:

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

  793.                     delete[] shandle.engineOptions.pathSF2;

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

  795.                 break;

  796.             case CB::PLUGIN_SFZ:

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

  798.                     delete[] shandle.engineOptions.pathSFZ;

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

  800.                 break;

  801.             }

  802.             break;

  803. 

  804.         case CB::ENGINE_OPTION_PATH_BINARIES:

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

  806. 

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

  808.                 delete[] shandle.engineOptions.binaryDir;

  809. 

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

  811.             break;

  812. 

  813.         case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  815. 

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

  817.                 delete[] shandle.engineOptions.resourceDir;

  818. 

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

  820.             break;

  821. 

  822.         case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  825.             break;

  826. 

  827.         case CB::ENGINE_OPTION_FRONTEND_BACKGROUND_COLOR:

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

  829.             break;

  830. 

  831.         case CB::ENGINE_OPTION_FRONTEND_FOREGROUND_COLOR:

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

  833.             break;

  834. 

  835.         case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  836.             CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  838.             break;

  839. 

  840.         case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  843.             CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  845.         }   break;

  846. 

  847. # ifndef CARLA_OS_WIN

  848.         case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  850. 

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

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

  853. 

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

  855.             break;

  856. 

  857.         case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  860.             break;

  861. 

  862.         case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  864. 

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

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

  867. 

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

  869.             break;

  870. 

  871.         case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  874.             break;

  875. 

  876.         case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  879.             break;

  880. 

  881.         case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  884.             break;

  885. # endif // CARLA_OS_WIN

  886. 

  887.         case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  889.             break;

  890.         }

  891.     }

  892. 

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

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

  895. }

  896. #endif // BUILD_BRIDGE

  897. 

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

  899. {

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

  901. 

  902.     if (handle->isStandalone)

  903.     {

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

  905. 

  906.         shandle.fileCallback    = func;

  907.         shandle.fileCallbackPtr = ptr;

  908.     }

  909. 

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

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

  912. }

  913. 

  914. // --------------------------------------------------------------------------------------------------------------------

  915. 

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

  917. {

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

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

  920. 

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

  922. 

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

  924. }

  925. 

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

  927. {

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

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

  930. 

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

  932. 

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

  934. }

  935. 

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

  937. {

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

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

  940. 

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

  942. 

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

  944. }

  945. 

  946. #ifndef BUILD_BRIDGE

  947. void carla_clear_project_filename(CarlaHostHandle handle)

  948. {

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

  950. 

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

  952. 

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

  954. }

  955. 

  956. // --------------------------------------------------------------------------------------------------------------------

  957. 

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

  959. {

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

  961. 

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

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

  964. 

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

  966. }

  967. 

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

  969. {

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

  971. 

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

  973. 

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

  975. }

  976. 

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

  978. {

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

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

  981. 

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

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

  984. 

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

  986.         return true;

  987. 

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

  989. }

  990. 

  991. bool carla_patchbay_refresh(CarlaHostHandle handle, bool external)

  992. {

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

  994. 

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

  996. 

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

  998. }

  999. 

  1000. // --------------------------------------------------------------------------------------------------------------------

  1001. 

  1002. void carla_transport_play(CarlaHostHandle handle)

  1003. {

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

  1005. 

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

  1007. 

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

  1009. }

  1010. 

  1011. void carla_transport_pause(CarlaHostHandle handle)

  1012. {

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

  1014. 

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

  1016. 

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

  1018. }

  1019. 

  1020. void carla_transport_bpm(CarlaHostHandle handle, double bpm)

  1021. {

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

  1023. 

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

  1025. 

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

  1027. }

  1028. 

  1029. void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame)

  1030. {

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

  1032. 

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

  1034. 

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

  1036. }

  1037. 

  1038. uint64_t carla_get_current_transport_frame(CarlaHostHandle handle)

  1039. {

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

  1041. 

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

  1043. }

  1044. 

  1045. const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle)

  1046. {

  1047.     static CarlaTransportInfo retTransInfo;

  1048.     retTransInfo.clear();

  1049. 

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

  1051. 

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

  1053. 

  1054.     retTransInfo.playing = timeInfo.playing;

  1055.     retTransInfo.frame   = timeInfo.frame;

  1056. 

  1057.     if (timeInfo.bbt.valid)

  1058.     {

  1059.         retTransInfo.bar  = timeInfo.bbt.bar;

  1060.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1063.     }

  1064. 

  1065.     return &retTransInfo;

  1066. }

  1067. #endif

  1068. 

  1069. // --------------------------------------------------------------------------------------------------------------------

  1070. 

  1071. uint32_t carla_get_current_plugin_count(CarlaHostHandle handle)

  1072. {

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

  1074. 

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

  1076. 

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

  1078. }

  1079. 

  1080. uint32_t carla_get_max_plugin_number(CarlaHostHandle handle)

  1081. {

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

  1083. 

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

  1085. 

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

  1087. }

  1088. 

  1089. // --------------------------------------------------------------------------------------------------------------------

  1090. 

  1091. bool carla_add_plugin(CarlaHostHandle handle,

  1092.                       BinaryType btype, PluginType ptype,

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

  1094.                       const void* extraPtr, uint options)

  1095. {

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

  1097. 

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

  1099.                 handle,

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

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

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

  1103. 

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

  1105. }

  1106. 

  1107. bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId)

  1108. {

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

  1110. 

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

  1112. 

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

  1114. }

  1115. 

  1116. bool carla_remove_all_plugins(CarlaHostHandle handle)

  1117. {

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

  1119. 

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

  1121. 

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

  1123. }

  1124. 

  1125. #ifndef BUILD_BRIDGE

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

  1127. {

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

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

  1130. 

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

  1132. 

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

  1134. }

  1135. 

  1136. bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId)

  1137. {

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

  1139. 

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

  1141. 

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

  1143. }

  1144. 

  1145. bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId)

  1146. {

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

  1148. 

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

  1150. 

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

  1152. }

  1153. 

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

  1155. {

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

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

  1158. 

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

  1160. 

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

  1162. }

  1163. #endif

  1164. 

  1165. // --------------------------------------------------------------------------------------------------------------------

  1166. 

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

  1168. {

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

  1170.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(handle->engine != nullptr

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

  1172. 

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

  1174.         return plugin->loadStateFromFile(filename);

  1175. 

  1176.     return false;

  1177. }

  1178. 

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

  1180. {

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

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

  1183. 

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

  1185.         return plugin->saveStateToFile(filename);

  1186. 

  1187.     return false;

  1188. }

  1189. 

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

  1191. {

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

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

  1194. 

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

  1196.         return plugin->exportAsLV2(lv2path);

  1197. 

  1198.     return false;

  1199. }

  1200. 

  1201. // --------------------------------------------------------------------------------------------------------------------

  1202. 

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

  1204. {

  1205.     static CarlaPluginInfo retInfo;

  1206. 

  1207.     // reset

  1208.     retInfo.type             = CB::PLUGIN_NONE;

  1209.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1210.     retInfo.hints            = 0x0;

  1211.     retInfo.optionsAvailable = 0x0;

  1212.     retInfo.optionsEnabled   = 0x0;

  1213.     retInfo.filename         = gNullCharPtr;

  1214.     retInfo.name             = gNullCharPtr;

  1215.     retInfo.iconName         = gNullCharPtr;

  1216.     retInfo.uniqueId         = 0;

  1217. 

  1218.     // cleanup

  1219.     if (retInfo.label != gNullCharPtr)

  1220.     {

  1221.         delete[] retInfo.label;

  1222.         retInfo.label = gNullCharPtr;

  1223.     }

  1224. 

  1225.     if (retInfo.maker != gNullCharPtr)

  1226.     {

  1227.         delete[] retInfo.maker;

  1228.         retInfo.maker = gNullCharPtr;

  1229.     }

  1230. 

  1231.     if (retInfo.copyright != gNullCharPtr)

  1232.     {

  1233.         delete[] retInfo.copyright;

  1234.         retInfo.copyright = gNullCharPtr;

  1235.     }

  1236. 

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

  1238. 

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

  1240.     {

  1241.         char strBuf[STR_MAX+1];

  1242.         carla_zeroChars(strBuf, STR_MAX+1);

  1243. 

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

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

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

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

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

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

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

  1251. 

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

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

  1254. 

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

  1256.             retInfo.label = carla_strdup_safe(strBuf);

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

  1258.             retInfo.maker = carla_strdup_safe(strBuf);

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

  1260.             retInfo.copyright = carla_strdup_safe(strBuf);

  1261. 

  1262.         checkStringPtr(retInfo.filename);

  1263.         checkStringPtr(retInfo.name);

  1264.         checkStringPtr(retInfo.iconName);

  1265.         checkStringPtr(retInfo.label);

  1266.         checkStringPtr(retInfo.maker);

  1267.         checkStringPtr(retInfo.copyright);

  1268.     }

  1269. 

  1270.     return &retInfo;

  1271. }

  1272. 

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

  1274. {

  1275.     static CarlaPortCountInfo retInfo;

  1276.     carla_zeroStruct(retInfo);

  1277. 

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

  1279. 

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

  1281.     {

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

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

  1284.     }

  1285. 

  1286.     return &retInfo;

  1287. }

  1288. 

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

  1290. {

  1291.     static CarlaPortCountInfo retInfo;

  1292.     carla_zeroStruct(retInfo);

  1293. 

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

  1295. 

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

  1297.     {

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

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

  1300.     }

  1301. 

  1302.     return &retInfo;

  1303. }

  1304. 

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

  1306. {

  1307.     static CarlaPortCountInfo retInfo;

  1308.     carla_zeroStruct(retInfo);

  1309. 

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

  1311. 

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

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

  1314. 

  1315.     return &retInfo;

  1316. }

  1317. 

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

  1319. {

  1320.     static CarlaParameterInfo retInfo(gNullCharPtr);

  1321. 

  1322.     // reset

  1323.     retInfo.scalePointCount = 0;

  1324. 

  1325.     // cleanup

  1326.     if (retInfo.name != gNullCharPtr)

  1327.     {

  1328.         delete[] retInfo.name;

  1329.         retInfo.name = gNullCharPtr;

  1330.     }

  1331. 

  1332.     if (retInfo.symbol != gNullCharPtr)

  1333.     {

  1334.         delete[] retInfo.symbol;

  1335.         retInfo.symbol = gNullCharPtr;

  1336.     }

  1337. 

  1338.     if (retInfo.unit != gNullCharPtr)

  1339.     {

  1340.         delete[] retInfo.unit;

  1341.         retInfo.unit = gNullCharPtr;

  1342.     }

  1343. 

  1344.     if (retInfo.comment != gNullCharPtr)

  1345.     {

  1346.         delete[] retInfo.comment;

  1347.         retInfo.comment = gNullCharPtr;

  1348.     }

  1349. 

  1350.     if (retInfo.groupName != gNullCharPtr)

  1351.     {

  1352.         delete[] retInfo.groupName;

  1353.         retInfo.groupName = gNullCharPtr;

  1354.     }

  1355. 

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

  1357. 

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

  1359.     {

  1360.         char strBuf[STR_MAX+1];

  1361.         carla_zeroChars(strBuf, STR_MAX+1);

  1362. 

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

  1364. 

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

  1366.         {

  1367.             retInfo.name = carla_strdup_safe(strBuf);

  1368.             carla_zeroChars(strBuf, STR_MAX+1);

  1369.         }

  1370. 

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

  1372.         {

  1373.             retInfo.symbol = carla_strdup_safe(strBuf);

  1374.             carla_zeroChars(strBuf, STR_MAX+1);

  1375.         }

  1376. 

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

  1378.         {

  1379.             retInfo.unit = carla_strdup_safe(strBuf);

  1380.             carla_zeroChars(strBuf, STR_MAX+1);

  1381.         }

  1382. 

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

  1384.         {

  1385.             retInfo.comment = carla_strdup_safe(strBuf);

  1386.             carla_zeroChars(strBuf, STR_MAX+1);

  1387.         }

  1388. 

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

  1390.         {

  1391.             retInfo.groupName = carla_strdup_safe(strBuf);

  1392.             carla_zeroChars(strBuf, STR_MAX+1);

  1393.         }

  1394. 

  1395.         checkStringPtr(retInfo.name);

  1396.         checkStringPtr(retInfo.symbol);

  1397.         checkStringPtr(retInfo.unit);

  1398.         checkStringPtr(retInfo.comment);

  1399.         checkStringPtr(retInfo.groupName);

  1400.     }

  1401. 

  1402.     return &retInfo;

  1403. }

  1404. 

  1405. const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle,

  1406.                                                                uint pluginId,

  1407.                                                                uint32_t parameterId,

  1408.                                                                uint32_t scalePointId)

  1409. {

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

  1411. 

  1412.     static CarlaScalePointInfo retInfo;

  1413. 

  1414.     // reset

  1415.     retInfo.value = 0.0f;

  1416. 

  1417.     // cleanup

  1418.     if (retInfo.label != gNullCharPtr)

  1419.     {

  1420.         delete[] retInfo.label;

  1421.         retInfo.label = gNullCharPtr;

  1422.     }

  1423. 

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

  1425. 

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

  1427.     {

  1428.         char strBuf[STR_MAX+1];

  1429. 

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

  1431. 

  1432.         carla_zeroChars(strBuf, STR_MAX+1);

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

  1434.             retInfo.label = carla_strdup_safe(strBuf);

  1435. 

  1436.         checkStringPtr(retInfo.label);

  1437.     }

  1438. 

  1439.     return &retInfo;

  1440. }

  1441. 

  1442. // --------------------------------------------------------------------------------------------------------------------

  1443. 

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

  1445. {

  1446.     static ParameterData retParamData;

  1447. 

  1448.     // reset

  1449.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1450.     retParamData.hints       = 0x0;

  1451.     retParamData.index       = CB::PARAMETER_NULL;

  1452.     retParamData.rindex      = -1;

  1453.     retParamData.midiChannel = 0;

  1454.     retParamData.mappedControlIndex = CB::CONTROL_INDEX_NONE;

  1455.     retParamData.mappedMinimum = 0.0f;

  1456.     retParamData.mappedMaximum = 0.0f;

  1457. 

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

  1459. 

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

  1461.     {

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

  1463. 

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

  1465.         retParamData.type        = pluginParamData.type;

  1466.         retParamData.hints       = pluginParamData.hints;

  1467.         retParamData.index       = pluginParamData.index;

  1468.         retParamData.rindex      = pluginParamData.rindex;

  1469.         retParamData.midiChannel = pluginParamData.midiChannel;

  1470.         retParamData.mappedControlIndex = pluginParamData.mappedControlIndex;

  1471.         retParamData.mappedMinimum = pluginParamData.mappedMinimum;

  1472.         retParamData.mappedMaximum = pluginParamData.mappedMaximum;

  1473.     }

  1474. 

  1475.     return &retParamData;

  1476. }

  1477. 

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

  1479. {

  1480.     static ParameterRanges retParamRanges;

  1481. 

  1482.     // reset

  1483.     retParamRanges.def       = 0.0f;

  1484.     retParamRanges.min       = 0.0f;

  1485.     retParamRanges.max       = 1.0f;

  1486.     retParamRanges.step      = 0.01f;

  1487.     retParamRanges.stepSmall = 0.0001f;

  1488.     retParamRanges.stepLarge = 0.1f;

  1489. 

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

  1491. 

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

  1493.     {

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

  1495. 

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

  1497.         retParamRanges.def       = pluginParamRanges.def;

  1498.         retParamRanges.min       = pluginParamRanges.min;

  1499.         retParamRanges.max       = pluginParamRanges.max;

  1500.         retParamRanges.step      = pluginParamRanges.step;

  1501.         retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1502.         retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1503.     }

  1504. 

  1505.     return &retParamRanges;

  1506. }

  1507. 

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

  1509. {

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

  1511. 

  1512.     // reset

  1513.     retMidiProgData.bank    = 0;

  1514.     retMidiProgData.program = 0;

  1515. 

  1516.     if (retMidiProgData.name != gNullCharPtr)

  1517.     {

  1518.         delete[] retMidiProgData.name;

  1519.         retMidiProgData.name = gNullCharPtr;

  1520.     }

  1521. 

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

  1523. 

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

  1525.     {

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

  1527. 

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

  1529.         retMidiProgData.bank    = pluginMidiProgData.bank;

  1530.         retMidiProgData.program = pluginMidiProgData.program;

  1531. 

  1532.         if (pluginMidiProgData.name != nullptr)

  1533.         {

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

  1535.             checkStringPtr(retMidiProgData.name);

  1536.         }

  1537.         else

  1538.         {

  1539.             retMidiProgData.name = gNullCharPtr;

  1540.         }

  1541.     }

  1542. 

  1543.     return &retMidiProgData;

  1544. }

  1545. 

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

  1547. {

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

  1549. 

  1550.     // reset

  1551.     if (retCustomData.type != gNullCharPtr)

  1552.     {

  1553.         delete[] retCustomData.type;

  1554.         retCustomData.type = gNullCharPtr;

  1555.     }

  1556. 

  1557.     if (retCustomData.key != gNullCharPtr)

  1558.     {

  1559.         delete[] retCustomData.key;

  1560.         retCustomData.key = gNullCharPtr;

  1561.     }

  1562. 

  1563.     if (retCustomData.value != gNullCharPtr)

  1564.     {

  1565.         delete[] retCustomData.value;

  1566.         retCustomData.value = gNullCharPtr;

  1567.     }

  1568. 

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

  1570. 

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

  1572.     {

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

  1574. 

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

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

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

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

  1579.         checkStringPtr(retCustomData.type);

  1580.         checkStringPtr(retCustomData.key);

  1581.         checkStringPtr(retCustomData.value);

  1582.     }

  1583. 

  1584.     return &retCustomData;

  1585. }

  1586. 

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

  1588. {

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

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

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

  1592. 

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

  1594.     {

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

  1596. 

  1597.         if (count == 0)

  1598.             return gNullCharPtr;

  1599. 

  1600.         static CarlaString customDataValue;

  1601. 

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

  1603.         {

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

  1605. 

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

  1607.                 continue;

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

  1609.                 continue;

  1610. 

  1611.             customDataValue = pluginCustomData.value;

  1612.             return customDataValue.buffer();

  1613.         }

  1614.     }

  1615. 

  1616.     return gNullCharPtr;

  1617. }

  1618. 

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

  1620. {

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

  1622. 

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

  1624.     {

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

  1626. 

  1627.         void* data = nullptr;

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

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

  1630. 

  1631.         static CarlaString chunkData;

  1632. 

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

  1634.         return chunkData.buffer();

  1635.     }

  1636. 

  1637.     return gNullCharPtr;

  1638. }

  1639. 

  1640. // --------------------------------------------------------------------------------------------------------------------

  1641. 

  1642. uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId)

  1643. {

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

  1645. 

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

  1647.         return plugin->getParameterCount();

  1648. 

  1649.     return 0;

  1650. }

  1651. 

  1652. uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId)

  1653. {

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

  1655. 

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

  1657.         return plugin->getProgramCount();

  1658. 

  1659.     return 0;

  1660. }

  1661. 

  1662. uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId)

  1663. {

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

  1665. 

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

  1667.         return plugin->getMidiProgramCount();

  1668. 

  1669.     return 0;

  1670. }

  1671. 

  1672. uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId)

  1673. {

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

  1675. 

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

  1677.         return plugin->getCustomDataCount();

  1678. 

  1679.     return 0;

  1680. }

  1681. 

  1682. // --------------------------------------------------------------------------------------------------------------------

  1683. 

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

  1685. {

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

  1687. 

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

  1689.     {

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

  1691. 

  1692.         static char textBuf[STR_MAX+1];

  1693.         carla_zeroChars(textBuf, STR_MAX+1);

  1694. 

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

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

  1697. 

  1698.         return textBuf;

  1699.     }

  1700. 

  1701.     return gNullCharPtr;

  1702. }

  1703. 

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

  1705. {

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

  1707. 

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

  1709.     {

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

  1711. 

  1712.         static char programName[STR_MAX+1];

  1713.         carla_zeroChars(programName, STR_MAX+1);

  1714. 

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

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

  1717. 

  1718.         return programName;

  1719.     }

  1720. 

  1721.     return gNullCharPtr;

  1722. }

  1723. 

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

  1725. {

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

  1727. 

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

  1729.     {

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

  1731. 

  1732.         static char midiProgramName[STR_MAX+1];

  1733.         carla_zeroChars(midiProgramName, STR_MAX+1);

  1734. 

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

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

  1737. 

  1738.         return midiProgramName;

  1739.     }

  1740. 

  1741.     return gNullCharPtr;

  1742. }

  1743. 

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

  1745. {

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

  1747. 

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

  1749.     {

  1750.         static char realPluginName[STR_MAX+1];

  1751.         carla_zeroChars(realPluginName, STR_MAX+1);

  1752. 

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

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

  1755. 

  1756.         return realPluginName;

  1757.     }

  1758. 

  1759.     return gNullCharPtr;

  1760. }

  1761. 

  1762. // --------------------------------------------------------------------------------------------------------------------

  1763. 

  1764. int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId)

  1765. {

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

  1767. 

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

  1769.         return plugin->getCurrentProgram();

  1770. 

  1771.     return -1;

  1772. }

  1773. 

  1774. int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId)

  1775. {

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

  1777. 

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

  1779.         return plugin->getCurrentMidiProgram();

  1780. 

  1781.     return -1;

  1782. }

  1783. 

  1784. // --------------------------------------------------------------------------------------------------------------------

  1785. 

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

  1787. {

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

  1789. 

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

  1791.     {

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

  1793. 

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

  1795.     }

  1796. 

  1797.     return 0.0f;

  1798. }

  1799. 

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

  1801. {

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

  1803. 

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

  1805.     {

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

  1807. 

  1808.         return plugin->getParameterValue(parameterId);

  1809.     }

  1810. 

  1811.     return 0.0f;

  1812. }

  1813. 

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

  1815. {

  1816. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

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

  1818. #else

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

  1820. #endif

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

  1822. 

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

  1824.         return plugin->getInternalParameterValue(parameterId);

  1825. 

  1826.     return 0.0f;

  1827. }

  1828. 

  1829. // --------------------------------------------------------------------------------------------------------------------

  1830. 

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

  1832. {

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

  1834. 

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

  1836. }

  1837. 

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

  1839. {

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

  1841. 

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

  1843. }

  1844. 

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

  1846. {

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

  1848. 

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

  1850. }

  1851. 

  1852. // --------------------------------------------------------------------------------------------------------------------

  1853. 

  1854. CARLA_BACKEND_START_NAMESPACE

  1855. 

  1856. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1857. // defined in CarlaPluginInternal.cpp

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

  1859. #endif

  1860. 

  1861. // defined in CarlaPluginLV2.cpp

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

  1863. 

  1864. CARLA_BACKEND_END_NAMESPACE

  1865. 

  1866. const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle,

  1867.                                                                   uint pluginId,

  1868.                                                                   uint32_t width, uint32_t height)

  1869. {

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

  1871. 

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

  1873.         return nullptr;

  1874. 

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

  1876.     {

  1877.         switch (plugin->getType())

  1878.         {

  1879. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1880.         case CB::PLUGIN_INTERNAL:

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

  1882. #endif

  1883.         case CB::PLUGIN_LV2:

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

  1885.         default:

  1886.             return nullptr;

  1887.         }

  1888.     }

  1889. 

  1890.     return nullptr;

  1891. }

  1892. 

  1893. // --------------------------------------------------------------------------------------------------------------------

  1894. 

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

  1896. {

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

  1898. 

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

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

  1901. }

  1902. 

  1903. #ifndef BUILD_BRIDGE

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

  1905. {

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

  1907. 

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

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

  1910. }

  1911. 

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

  1913. {

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

  1915. 

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

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

  1918. }

  1919. 

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

  1921. {

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

  1923. 

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

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

  1926. }

  1927. 

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

  1929. {

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

  1931. 

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

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

  1934. }

  1935. 

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

  1937. {

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

  1939. 

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

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

  1942. }

  1943. 

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

  1945. {

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

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

  1948. 

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

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

  1951. }

  1952. #endif

  1953. 

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

  1955. {

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

  1957. 

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

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

  1960. }

  1961. 

  1962. // --------------------------------------------------------------------------------------------------------------------

  1963. 

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

  1965. {

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

  1967. 

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

  1969.     {

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

  1971. 

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

  1973.     }

  1974. }

  1975. 

  1976. #ifndef BUILD_BRIDGE

  1977. 

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

  1979. {

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

  1981.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1982. 

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

  1984.     {

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

  1986. 

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

  1988.     }

  1989. }

  1990. 

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

  1992. {

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

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

  1995. 

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

  1997.     {

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

  1999. 

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

  2001.     }

  2002. }

  2003. 

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

  2005. {

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

  2007. 

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

  2009.     {

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

  2011. 

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

  2013.     }

  2014. }

  2015. 

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

  2017. {

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

  2019. 

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

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

  2022. }

  2023. #endif

  2024. 

  2025. // --------------------------------------------------------------------------------------------------------------------

  2026. 

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

  2028. {

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

  2030. 

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

  2032.     {

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

  2034. 

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

  2036.     }

  2037. }

  2038. 

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

  2040. {

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

  2042. 

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

  2044.     {

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

  2046. 

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

  2048.     }

  2049. }

  2050. 

  2051. // --------------------------------------------------------------------------------------------------------------------

  2052. 

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

  2054. {

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

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

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

  2058.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2059. 

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

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

  2062. }

  2063. 

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

  2065. {

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

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

  2068. 

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

  2070.     {

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

  2072. 

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

  2074. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2076. #else

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

  2078. #endif

  2079.     }

  2080. }

  2081. 

  2082. // --------------------------------------------------------------------------------------------------------------------

  2083. 

  2084. void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId)

  2085. {

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

  2087. 

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

  2089.         plugin->prepareForSave();

  2090. }

  2091. 

  2092. void carla_reset_parameters(CarlaHostHandle handle, uint pluginId)

  2093. {

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

  2095. 

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

  2097.         plugin->resetParameters();

  2098. }

  2099. 

  2100. void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId)

  2101. {

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

  2103. 

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

  2105.         plugin->randomizeParameters();

  2106. }

  2107. 

  2108. #ifndef BUILD_BRIDGE

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

  2110. {

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

  2112. 

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

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

  2115. }

  2116. #endif

  2117. 

  2118. void carla_set_custom_ui_prefix(CarlaHostHandle handle, uint pluginId, const char* prefix)

  2119. {

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

  2121.     CARLA_SAFE_ASSERT_RETURN(prefix != nullptr,);

  2122. 

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

  2124.         plugin->setCustomUIPrefix(prefix);

  2125. }

  2126. 

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

  2128. {

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

  2130. 

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

  2132.         plugin->showCustomUI(yesNo);

  2133. }

  2134. 

  2135. // --------------------------------------------------------------------------------------------------------------------

  2136. 

  2137. uint32_t carla_get_buffer_size(CarlaHostHandle handle)

  2138. {

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

  2140. 

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

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

  2143. }

  2144. 

  2145. double carla_get_sample_rate(CarlaHostHandle handle)

  2146. {

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

  2148. 

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

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

  2151. }

  2152. 

  2153. // --------------------------------------------------------------------------------------------------------------------

  2154. 

  2155. const char* carla_get_last_error(CarlaHostHandle handle)

  2156. {

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

  2158. 

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

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

  2161. 

  2162.     return handle->isStandalone

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

  2164.            : gNullCharPtr;

  2165. }

  2166. 

  2167. const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle)

  2168. {

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

  2170. 

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

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

  2173.     {

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

  2175.         if (handle->isStandalone)

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

  2177.         return gNullCharPtr;

  2178.     }

  2179. 

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

  2181. 

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

  2183.         return path;

  2184. 

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

  2186.     return notAvailable;

  2187. #else

  2188.     return gNullCharPtr;

  2189. 

  2190.     // unused

  2191.     (void)handle;

  2192. #endif

  2193. }

  2194. 

  2195. const char* carla_get_host_osc_url_udp(CarlaHostHandle handle)

  2196. {

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

  2198. 

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

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

  2201.     {

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

  2203.         if (handle->isStandalone)

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

  2205.         return gNullCharPtr;

  2206.     }

  2207. 

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

  2209. 

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

  2211.         return path;

  2212. 

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

  2214.     return notAvailable;

  2215. #else

  2216.     return gNullCharPtr;

  2217. 

  2218.     // unused

  2219.     (void)handle;

  2220. #endif

  2221. }

  2222. 

  2223. // --------------------------------------------------------------------------------------------------------------------

  2224. 

  2225. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2226. #include "CarlaPluginUI.cpp"

  2227. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2228. 

  2229. #include "CarlaDssiUtils.cpp"

  2230. #include "CarlaMacUtils.cpp"

  2231. #include "CarlaPatchbayUtils.cpp"

  2232. #include "CarlaPipeUtils.cpp"

  2233. #include "CarlaProcessUtils.cpp"

  2234. #include "CarlaStateUtils.cpp"

  2235. 

  2236. // --------------------------------------------------------------------------------------------------------------------