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

2263 lines
81KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngine.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "ThreadSafeFFTW.hpp"

  30. 

  31. #ifdef BUILD_BRIDGE

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

  33. #else

  34. # include "CarlaLogThread.hpp"

  35. #endif

  36. 

  37. #ifdef USING_JUCE

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

  39. #  pragma GCC diagnostic push

  40. #  pragma GCC diagnostic ignored "-Wconversion"

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

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

  43. #  pragma GCC diagnostic ignored "-Wundef"

  44. # endif

  45. 

  46. # include "AppConfig.h"

  47. # include "juce_events/juce_events.h"

  48. 

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

  50. #  pragma GCC diagnostic pop

  51. # endif

  52. #endif

  53. 

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

  55.     if (! (cond)) {                                              \

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

  57.         gStandalone.lastError = msg;                             \

  58.         return ret;                                              \

  59.     }

  60. 

  61. namespace CB = CarlaBackend;

  62. using CB::EngineOptions;

  63. 

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

  65. // Single, standalone engine

  66. 

  67. struct CarlaBackendStandalone {

  68.     CarlaEngine*       engine;

  69.     EngineCallbackFunc engineCallback;

  70.     void*              engineCallbackPtr;

  71. #ifndef BUILD_BRIDGE

  72.     EngineOptions      engineOptions;

  73.     CarlaLogThread     logThread;

  74.     bool               logThreadEnabled;

  75. #endif

  76. 

  77.     FileCallbackFunc fileCallback;

  78.     void*            fileCallbackPtr;

  79. 

  80.     CarlaString lastError;

  81. 

  82.     CarlaBackendStandalone() noexcept

  83.         : engine(nullptr),

  84.           engineCallback(nullptr),

  85.           engineCallbackPtr(nullptr),

  86. #ifndef BUILD_BRIDGE

  87.           engineOptions(),

  88.           logThread(),

  89.           logThreadEnabled(false),

  90. #endif

  91.           fileCallback(nullptr),

  92.           fileCallbackPtr(nullptr),

  93.           lastError() {}

  94. 

  95.     ~CarlaBackendStandalone() noexcept

  96.     {

  97.         CARLA_SAFE_ASSERT(engine == nullptr);

  98.     }

  99. 

  100.     CARLA_PREVENT_HEAP_ALLOCATION

  101.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  102. };

  103. 

  104. CarlaBackendStandalone gStandalone;

  105. 

  106. #ifdef CARLA_OS_UNIX

  107. static ThreadSafeFFTW sThreadSafeFFTW;

  108. #endif

  109. 

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

  111. // API

  112. 

  113. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  114. #include "CarlaHostCommon.cpp"

  115. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  116. 

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

  118. 

  119. uint carla_get_engine_driver_count()

  120. {

  121.     carla_debug("carla_get_engine_driver_count()");

  122. 

  123.     return CarlaEngine::getDriverCount();

  124. }

  125. 

  126. const char* carla_get_engine_driver_name(uint index)

  127. {

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

  129. 

  130.     return CarlaEngine::getDriverName(index);

  131. }

  132. 

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

  134. {

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

  136. 

  137.     return CarlaEngine::getDriverDeviceNames(index);

  138. }

  139. 

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

  141. {

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

  143. 

  144.     static EngineDriverDeviceInfo retDevInfo;

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

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

  147. 

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

  149. 

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

  151.     {

  152.         retDevInfo.hints       =  devInfo->hints;

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

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

  155.     }

  156.     else

  157.     {

  158.         retDevInfo.hints       = 0x0;

  159.         retDevInfo.bufferSizes = nullBufferSizes;

  160.         retDevInfo.sampleRates = nullSampleRates;

  161.     }

  162. 

  163.     return &retDevInfo;

  164. }

  165. 

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

  167. {

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

  169. }

  170. 

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

  172. 

  173. CarlaEngine* carla_get_engine()

  174. {

  175.     carla_debug("carla_get_engine()");

  176. 

  177.     return gStandalone.engine;

  178. }

  179. 

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

  181. 

  182. static void carla_engine_init_common(CarlaEngine* const engine)

  183. {

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

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

  186. 

  187. #ifdef BUILD_BRIDGE

  188.     using water::File;

  189.     File waterBinaryDir(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory());

  190. 

  191.     /*

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

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

  194. 

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

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

  197. 

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

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

  200.     */

  201. 

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

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

  204. 

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

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

  207. 

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

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

  210. 

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

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

  213. 

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

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

  216. 

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

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

  219. 

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

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

  222. 

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

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

  225. 

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

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

  228. 

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

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

  231. 

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

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

  234. 

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

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

  237. 

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

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

  240.     else

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

  242. 

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

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

  245.     else

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

  247. 

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

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

  250. 

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

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

  253. #else

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

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

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

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

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

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

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

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

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

  263. 

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

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

  266. 

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

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

  269. 

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

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

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

  273. 

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

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

  276. 

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

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

  279. 

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

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

  282. 

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

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

  285. 

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

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

  288. 

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

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

  291. 

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

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

  294. 

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

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

  297. 

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

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

  300. 

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

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

  303. 

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

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

  306. 

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

  308. 

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

  310. 

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

  312.     {

  313.         char strBuf[STR_MAX+1];

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

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

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

  317.     }

  318.     else

  319.     {

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

  321.     }

  322. 

  323. # ifndef CARLA_OS_WIN

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

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

  326. 

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

  328. 

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

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

  331. 

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

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

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

  335. # endif

  336. #endif

  337. }

  338. 

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

  340. {

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

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

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

  344. 

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

  346. 

  347. #ifdef CARLA_OS_WIN

  348.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  349. #endif

  350. 

  351. #ifdef USING_JUCE

  352.     juce::initialiseJuce_GUI();

  353. #endif

  354. 

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

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

  357. 

  358.     gStandalone.engine = engine;

  359. 

  360. #ifdef BUILD_BRIDGE

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

  362.     {

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

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

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

  366. 

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

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

  369.     }

  370.     else

  371.     {

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

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

  374.     }

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

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

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

  378. #else

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

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

  381. #endif

  382. 

  383.     carla_engine_init_common(engine);

  384. 

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

  386.     {

  387. #ifndef BUILD_BRIDGE

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

  389.             gStandalone.logThread.init();

  390. #endif

  391. #ifdef CARLA_OS_UNIX

  392.         sThreadSafeFFTW.init();

  393. #endif

  394.         gStandalone.lastError = "No error";

  395.         return true;

  396.     }

  397.     else

  398.     {

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

  400.         gStandalone.engine = nullptr;

  401.         delete engine;

  402. #ifdef USING_JUCE

  403.         juce::shutdownJuce_GUI();

  404. #endif

  405.         return false;

  406.     }

  407. }

  408. 

  409. #ifdef BUILD_BRIDGE

  410. bool carla_engine_init_bridge(const char audioBaseName[6+1], const char rtClientBaseName[6+1], const char nonRtClientBaseName[6+1],

  411.                               const char nonRtServerBaseName[6+1], const char* clientName)

  412. {

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

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

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

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

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

  418.     carla_debug("carla_engine_init_bridge(\"%s\", \"%s\", \"%s\", \"%s\", \"%s\")", audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName, clientName);

  419. 

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

  421. 

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

  423.                                                                   rtClientBaseName,

  424.                                                                   nonRtClientBaseName,

  425.                                                                   nonRtServerBaseName));

  426. 

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

  428. 

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

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

  431. 

  432.     carla_engine_init_common(engine);

  433. 

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

  435.     {

  436.         gStandalone.lastError = "No error";

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

  438.         return true;

  439.     }

  440.     else

  441.     {

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

  443.         return false;

  444.     }

  445. }

  446. #endif

  447. 

  448. bool carla_engine_close()

  449. {

  450.     carla_debug("carla_engine_close()");

  451. 

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

  453. 

  454. #ifdef CARLA_OS_UNIX

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

  456. #endif

  457. 

  458.     CarlaEngine* const engine = gStandalone.engine;

  459. 

  460.     engine->setAboutToClose();

  461.     engine->removeAllPlugins();

  462. 

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

  464. 

  465.     if (! closed)

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

  467. 

  468. #ifndef BUILD_BRIDGE

  469.     gStandalone.logThread.stop();

  470. #endif

  471. 

  472.     gStandalone.engine = nullptr;

  473.     delete engine;

  474. 

  475. #ifdef USING_JUCE

  476.     juce::shutdownJuce_GUI();

  477. #endif

  478.     return closed;

  479. }

  480. 

  481. void carla_engine_idle()

  482. {

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

  484. 

  485.     gStandalone.engine->idle();

  486. 

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

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

  489.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  490. 

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

  492. #endif

  493. }

  494. 

  495. bool carla_is_engine_running()

  496. {

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

  498. }

  499. 

  500. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info()

  501. {

  502.     static CarlaRuntimeEngineInfo retInfo;

  503. 

  504.     // reset

  505.     retInfo.load = 0.0f;

  506.     retInfo.xruns = 0;

  507. 

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

  509. 

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

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

  512. 

  513.     return &retInfo;

  514. }

  515. 

  516. #ifndef BUILD_BRIDGE

  517. const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info()

  518. {

  519.     static CarlaRuntimeEngineDriverDeviceInfo retInfo;

  520. 

  521.     // reset

  522.     retInfo.name = gNullCharPtr;

  523.     retInfo.hints = 0x0;

  524.     retInfo.bufferSize = 0;

  525.     retInfo.bufferSizes = nullptr;

  526.     retInfo.sampleRate = 0.0;

  527.     retInfo.sampleRates = nullptr;

  528. 

  529.     const char* audioDriver;

  530.     const char* audioDevice;

  531. 

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

  533.     {

  534.         audioDriver = engine->getCurrentDriverName();

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

  536. 

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

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

  539.     }

  540.     else

  541.     {

  542.         audioDriver = gStandalone.engineOptions.audioDriver;

  543.         audioDevice = gStandalone.engineOptions.audioDevice;

  544. 

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

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

  547.     }

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

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

  550. 

  551.     uint index = 0;

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

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

  554.     {

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

  556.         CARLA_SAFE_ASSERT_CONTINUE(testDriverName != nullptr);

  557. 

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

  559.             break;

  560.     }

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

  562. 

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

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

  565. 

  566.     retInfo.name        = audioDevice;

  567.     retInfo.hints       = devInfo->hints;

  568.     retInfo.bufferSizes = devInfo->bufferSizes;

  569.     retInfo.sampleRates = devInfo->sampleRates;

  570. 

  571.     return &retInfo;

  572. }

  573. 

  574. bool carla_set_engine_buffer_size_and_sample_rate(uint bufferSize, double sampleRate)

  575. {

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

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

  578. 

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

  580. }

  581. 

  582. bool carla_show_engine_device_control_panel()

  583. {

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

  585.     carla_debug("carla_show_engine_device_control_panel()");

  586. 

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

  588. }

  589. #endif

  590. 

  591. void carla_clear_engine_xruns()

  592. {

  593.     if (gStandalone.engine != nullptr)

  594.         gStandalone.engine->clearXruns();

  595. }

  596. 

  597. void carla_cancel_engine_action()

  598. {

  599.     if (gStandalone.engine != nullptr)

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

  601. }

  602. 

  603. bool carla_set_engine_about_to_close()

  604. {

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

  606.     carla_debug("carla_set_engine_about_to_close()");

  607. 

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

  609. }

  610. 

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

  612. {

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

  614. 

  615.     gStandalone.engineCallback    = func;

  616.     gStandalone.engineCallbackPtr = ptr;

  617. 

  618. #ifndef BUILD_BRIDGE

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

  620. #endif

  621. 

  622.     if (gStandalone.engine != nullptr)

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

  624. }

  625. 

  626. #ifndef BUILD_BRIDGE

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

  628. {

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

  630. 

  631.     switch (option)

  632.     {

  633.     case CB::ENGINE_OPTION_DEBUG:

  634.         break;

  635. 

  636.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  639.         break;

  640. 

  641.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  643. 

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

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

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

  647.         {

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

  649. 

  650.             if (gStandalone.engineCallback != nullptr)

  651.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,

  652.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  653.                                            0,

  654.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  655.                                            0, 0, 0.0f,

  656.                                            gStandalone.engineOptions.transportExtra);

  657.         }

  658.         else

  659.         {

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

  661.         }

  662. 

  663.         delete[] gStandalone.engineOptions.transportExtra;

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

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

  666.         else

  667.             gStandalone.engineOptions.transportExtra = nullptr;

  668.         break;

  669. 

  670.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  673.         break;

  674. 

  675.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  678.         break;

  679. 

  680.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  683.         break;

  684. 

  685.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  688.         break;

  689. 

  690.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  691.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  693.         break;

  694. 

  695.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  696.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  698.         break;

  699. 

  700.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  701.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  703.         break;

  704. 

  705.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  706.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  708.         break;

  709. 

  710.     case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  713.         break;

  714. 

  715.     case CB::ENGINE_OPTION_AUDIO_DRIVER:

  716.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  717. 

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

  719.             delete[] gStandalone.engineOptions.audioDriver;

  720. 

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

  722.         break;

  723. 

  724.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  725.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  726. 

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

  728.             delete[] gStandalone.engineOptions.audioDevice;

  729. 

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

  731.         break;

  732. 

  733.     case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  736.         break;

  737. 

  738.     case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  740.         gStandalone.engineOptions.oscPortTCP = value;

  741.         break;

  742. 

  743.     case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  745.         gStandalone.engineOptions.oscPortUDP = value;

  746.         break;

  747. 

  748.     case CB::ENGINE_OPTION_FILE_PATH:

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

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

  751.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  752. 

  753.         switch (value)

  754.         {

  755.         case CB::FILE_AUDIO:

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

  757.                 delete[] gStandalone.engineOptions.pathAudio;

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

  759.             break;

  760.         case CB::FILE_MIDI:

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

  762.                 delete[] gStandalone.engineOptions.pathMIDI;

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

  764.             break;

  765.         }

  766.         break;

  767. 

  768.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  771.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  772. 

  773.         switch (value)

  774.         {

  775.         case CB::PLUGIN_LADSPA:

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

  777.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  779.             break;

  780.         case CB::PLUGIN_DSSI:

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

  782.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  784.             break;

  785.         case CB::PLUGIN_LV2:

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

  787.                 delete[] gStandalone.engineOptions.pathLV2;

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

  789.             break;

  790.         case CB::PLUGIN_VST2:

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

  792.                 delete[] gStandalone.engineOptions.pathVST2;

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

  794.             break;

  795.         case CB::PLUGIN_VST3:

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

  797.                 delete[] gStandalone.engineOptions.pathVST3;

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

  799.             break;

  800.         case CB::PLUGIN_SF2:

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

  802.                 delete[] gStandalone.engineOptions.pathSF2;

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

  804.             break;

  805.         case CB::PLUGIN_SFZ:

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

  807.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  809.             break;

  810.         }

  811.         break;

  812. 

  813.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  815. 

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

  817.             delete[] gStandalone.engineOptions.binaryDir;

  818. 

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

  820.         break;

  821. 

  822.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  824. 

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

  826.             delete[] gStandalone.engineOptions.resourceDir;

  827. 

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

  829.         break;

  830. 

  831.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  834.         break;

  835. 

  836.     case CB::ENGINE_OPTION_FRONTEND_UI_SCALE:

  837.         CARLA_SAFE_ASSERT_RETURN(value > 0,);

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

  839.         break;

  840. 

  841.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  844.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  846.     }   break;

  847. 

  848. #ifndef CARLA_OS_WIN

  849.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  851. 

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

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

  854. 

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

  856.         break;

  857. 

  858.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  861.         break;

  862. 

  863.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  865. 

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

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

  868. 

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

  870.         break;

  871. 

  872.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  875.         break;

  876. 

  877.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  880.         break;

  881. 

  882.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  885.         break;

  886. #endif

  887. 

  888.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  890.         break;

  891.     }

  892. 

  893.     if (gStandalone.engine != nullptr)

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

  895. }

  896. #endif

  897. 

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

  899. {

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

  901. 

  902.     gStandalone.fileCallback    = func;

  903.     gStandalone.fileCallbackPtr = ptr;

  904. 

  905.     if (gStandalone.engine != nullptr)

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

  907. }

  908. 

  909. // --------------------------------------------------------------------------------------------------------------------

  910. 

  911. bool carla_load_file(const char* filename)

  912. {

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

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

  915. 

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

  917. 

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

  919. }

  920. 

  921. bool carla_load_project(const char* filename)

  922. {

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

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

  925. 

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

  927. 

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

  929. }

  930. 

  931. bool carla_save_project(const char* filename)

  932. {

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

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

  935. 

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

  937. 

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

  939. }

  940. 

  941. #ifndef BUILD_BRIDGE

  942. void carla_clear_project_filename()

  943. {

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

  945. 

  946.     carla_debug("carla_clear_project_filename()");

  947. 

  948.     gStandalone.engine->clearCurrentProjectFilename();

  949. }

  950. 

  951. // --------------------------------------------------------------------------------------------------------------------

  952. 

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

  954. {

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

  956. 

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

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

  959. 

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

  961. }

  962. 

  963. bool carla_patchbay_disconnect(bool external, uint connectionId)

  964. {

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

  966. 

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

  968. 

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

  970. }

  971. 

  972. bool carla_patchbay_refresh(bool external)

  973. {

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

  975. 

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

  977. 

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

  979. }

  980. 

  981. // --------------------------------------------------------------------------------------------------------------------

  982. 

  983. void carla_transport_play()

  984. {

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

  986. 

  987.     carla_debug("carla_transport_play()");

  988. 

  989.     gStandalone.engine->transportPlay();

  990. }

  991. 

  992. void carla_transport_pause()

  993. {

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

  995. 

  996.     carla_debug("carla_transport_pause()");

  997. 

  998.     gStandalone.engine->transportPause();

  999. }

  1000. 

  1001. void carla_transport_bpm(double bpm)

  1002. {

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

  1004. 

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

  1006. 

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

  1008. }

  1009. 

  1010. void carla_transport_relocate(uint64_t frame)

  1011. {

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

  1013. 

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

  1015. 

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

  1017. }

  1018. 

  1019. uint64_t carla_get_current_transport_frame()

  1020. {

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

  1022. 

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

  1024. }

  1025. 

  1026. const CarlaTransportInfo* carla_get_transport_info()

  1027. {

  1028.     static CarlaTransportInfo retTransInfo;

  1029.     retTransInfo.clear();

  1030. 

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

  1032. 

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

  1034. 

  1035.     retTransInfo.playing = timeInfo.playing;

  1036.     retTransInfo.frame   = timeInfo.frame;

  1037. 

  1038.     if (timeInfo.bbt.valid)

  1039.     {

  1040.         retTransInfo.bar  = timeInfo.bbt.bar;

  1041.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  1044.     }

  1045. 

  1046.     return &retTransInfo;

  1047. }

  1048. #endif

  1049. 

  1050. // --------------------------------------------------------------------------------------------------------------------

  1051. 

  1052. uint32_t carla_get_current_plugin_count()

  1053. {

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

  1055. 

  1056.     carla_debug("carla_get_current_plugin_count()");

  1057. 

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

  1059. }

  1060. 

  1061. uint32_t carla_get_max_plugin_number()

  1062. {

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

  1064. 

  1065.     carla_debug("carla_get_max_plugin_number()");

  1066. 

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

  1068. }

  1069. 

  1070. // --------------------------------------------------------------------------------------------------------------------

  1071. 

  1072. bool carla_add_plugin(BinaryType btype, PluginType ptype,

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

  1074.                       const void* extraPtr, uint options)

  1075. {

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

  1077. 

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

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

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

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

  1082. 

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

  1084. }

  1085. 

  1086. bool carla_remove_plugin(uint pluginId)

  1087. {

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

  1089. 

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

  1091. 

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

  1093. }

  1094. 

  1095. bool carla_remove_all_plugins()

  1096. {

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

  1098. 

  1099.     carla_debug("carla_remove_all_plugins()");

  1100. 

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

  1102. }

  1103. 

  1104. #ifndef BUILD_BRIDGE

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

  1106. {

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

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

  1109. 

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

  1111. 

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

  1113. }

  1114. 

  1115. bool carla_clone_plugin(uint pluginId)

  1116. {

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

  1118. 

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

  1120. 

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

  1122. }

  1123. 

  1124. bool carla_replace_plugin(uint pluginId)

  1125. {

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

  1127. 

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

  1129. 

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

  1131. }

  1132. 

  1133. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1134. {

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

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

  1137. 

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

  1139. 

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

  1141. }

  1142. #endif

  1143. 

  1144. // --------------------------------------------------------------------------------------------------------------------

  1145. 

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

  1147. {

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

  1149.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr

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

  1151. 

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

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

  1154. 

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

  1156. 

  1157.     return plugin->loadStateFromFile(filename);

  1158. }

  1159. 

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

  1161. {

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

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

  1164. 

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

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

  1167. 

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

  1169. 

  1170.     return plugin->saveStateToFile(filename);

  1171. }

  1172. 

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

  1174. {

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

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

  1177. 

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

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

  1180. 

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

  1182. 

  1183.     return plugin->exportAsLV2(lv2path);

  1184. }

  1185. 

  1186. // --------------------------------------------------------------------------------------------------------------------

  1187. 

  1188. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1189. {

  1190.     static CarlaPluginInfo retInfo;

  1191. 

  1192.     // reset

  1193.     retInfo.type             = CB::PLUGIN_NONE;

  1194.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1195.     retInfo.hints            = 0x0;

  1196.     retInfo.optionsAvailable = 0x0;

  1197.     retInfo.optionsEnabled   = 0x0;

  1198.     retInfo.filename         = gNullCharPtr;

  1199.     retInfo.name             = gNullCharPtr;

  1200.     retInfo.iconName         = gNullCharPtr;

  1201.     retInfo.uniqueId         = 0;

  1202. 

  1203.     // cleanup

  1204.     if (retInfo.label != gNullCharPtr)

  1205.     {

  1206.         delete[] retInfo.label;

  1207.         retInfo.label = gNullCharPtr;

  1208.     }

  1209. 

  1210.     if (retInfo.maker != gNullCharPtr)

  1211.     {

  1212.         delete[] retInfo.maker;

  1213.         retInfo.maker = gNullCharPtr;

  1214.     }

  1215. 

  1216.     if (retInfo.copyright != gNullCharPtr)

  1217.     {

  1218.         delete[] retInfo.copyright;

  1219.         retInfo.copyright = gNullCharPtr;

  1220.     }

  1221. 

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

  1223. 

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

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

  1226. 

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

  1228. 

  1229.     char strBuf[STR_MAX+1];

  1230.     carla_zeroChars(strBuf, STR_MAX+1);

  1231. 

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

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

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

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

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

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

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

  1239. 

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

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

  1242. 

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

  1244.         retInfo.label = carla_strdup_safe(strBuf);

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

  1246.         retInfo.maker = carla_strdup_safe(strBuf);

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

  1248.         retInfo.copyright = carla_strdup_safe(strBuf);

  1249. 

  1250.     checkStringPtr(retInfo.filename);

  1251.     checkStringPtr(retInfo.name);

  1252.     checkStringPtr(retInfo.iconName);

  1253.     checkStringPtr(retInfo.label);

  1254.     checkStringPtr(retInfo.maker);

  1255.     checkStringPtr(retInfo.copyright);

  1256. 

  1257.     return &retInfo;

  1258. }

  1259. 

  1260. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1261. {

  1262.     static CarlaPortCountInfo retInfo;

  1263.     carla_zeroStruct(retInfo);

  1264. 

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

  1266. 

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

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

  1269. 

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

  1271. 

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

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

  1274.     return &retInfo;

  1275. }

  1276. 

  1277. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1278. {

  1279.     static CarlaPortCountInfo retInfo;

  1280.     carla_zeroStruct(retInfo);

  1281. 

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

  1283. 

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

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

  1286. 

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

  1288. 

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

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

  1291.     return &retInfo;

  1292. }

  1293. 

  1294. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1295. {

  1296.     static CarlaPortCountInfo retInfo;

  1297.     carla_zeroStruct(retInfo);

  1298. 

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

  1300. 

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

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

  1303. 

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

  1305. 

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

  1307.     return &retInfo;

  1308. }

  1309. 

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

  1311. {

  1312.     static CarlaParameterInfo retInfo;

  1313. 

  1314.     // reset

  1315.     retInfo.scalePointCount = 0;

  1316. 

  1317.     // cleanup

  1318.     if (retInfo.name != gNullCharPtr)

  1319.     {

  1320.         delete[] retInfo.name;

  1321.         retInfo.name = gNullCharPtr;

  1322.     }

  1323. 

  1324.     if (retInfo.symbol != gNullCharPtr)

  1325.     {

  1326.         delete[] retInfo.symbol;

  1327.         retInfo.symbol = gNullCharPtr;

  1328.     }

  1329. 

  1330.     if (retInfo.unit != gNullCharPtr)

  1331.     {

  1332.         delete[] retInfo.unit;

  1333.         retInfo.unit = gNullCharPtr;

  1334.     }

  1335. 

  1336.     if (retInfo.comment != gNullCharPtr)

  1337.     {

  1338.         delete[] retInfo.comment;

  1339.         retInfo.comment = gNullCharPtr;

  1340.     }

  1341. 

  1342.     if (retInfo.groupName != gNullCharPtr)

  1343.     {

  1344.         delete[] retInfo.groupName;

  1345.         retInfo.groupName = gNullCharPtr;

  1346.     }

  1347. 

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

  1349. 

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

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

  1352. 

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

  1354. 

  1355.     char strBuf[STR_MAX+1];

  1356.     carla_zeroChars(strBuf, STR_MAX+1);

  1357. 

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

  1359. 

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

  1361.     {

  1362.         retInfo.name = carla_strdup_safe(strBuf);

  1363.         carla_zeroChars(strBuf, STR_MAX+1);

  1364.     }

  1365. 

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

  1367.     {

  1368.         retInfo.symbol = carla_strdup_safe(strBuf);

  1369.         carla_zeroChars(strBuf, STR_MAX+1);

  1370.     }

  1371. 

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

  1373.     {

  1374.         retInfo.unit = carla_strdup_safe(strBuf);

  1375.         carla_zeroChars(strBuf, STR_MAX+1);

  1376.     }

  1377. 

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

  1379.     {

  1380.         retInfo.comment = carla_strdup_safe(strBuf);

  1381.         carla_zeroChars(strBuf, STR_MAX+1);

  1382.     }

  1383. 

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

  1385.     {

  1386.         retInfo.groupName = carla_strdup_safe(strBuf);

  1387.         carla_zeroChars(strBuf, STR_MAX+1);

  1388.     }

  1389. 

  1390.     checkStringPtr(retInfo.name);

  1391.     checkStringPtr(retInfo.symbol);

  1392.     checkStringPtr(retInfo.unit);

  1393.     checkStringPtr(retInfo.comment);

  1394.     checkStringPtr(retInfo.groupName);

  1395. 

  1396.     return &retInfo;

  1397. }

  1398. 

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

  1400. {

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

  1402. 

  1403.     static CarlaScalePointInfo retInfo;

  1404. 

  1405.     // reset

  1406.     retInfo.value = 0.0f;

  1407. 

  1408.     // cleanup

  1409.     if (retInfo.label != gNullCharPtr)

  1410.     {

  1411.         delete[] retInfo.label;

  1412.         retInfo.label = gNullCharPtr;

  1413.     }

  1414. 

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

  1416. 

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

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

  1419. 

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

  1421. 

  1422.     char strBuf[STR_MAX+1];

  1423. 

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

  1425. 

  1426.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1428.         retInfo.label = carla_strdup_safe(strBuf);

  1429. 

  1430.     checkStringPtr(retInfo.label);

  1431. 

  1432.     return &retInfo;

  1433. }

  1434. 

  1435. // --------------------------------------------------------------------------------------------------------------------

  1436. 

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

  1438. {

  1439.     static ParameterData retParamData;

  1440. 

  1441.     // reset

  1442.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1443.     retParamData.hints       = 0x0;

  1444.     retParamData.index       = CB::PARAMETER_NULL;

  1445.     retParamData.rindex      = -1;

  1446.     retParamData.midiCC      = -1;

  1447.     retParamData.midiChannel = 0;

  1448. 

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

  1450. 

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

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

  1453. 

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

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

  1456. 

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

  1458.     retParamData.type        = pluginParamData.type;

  1459.     retParamData.hints       = pluginParamData.hints;

  1460.     retParamData.index       = pluginParamData.index;

  1461.     retParamData.rindex      = pluginParamData.rindex;

  1462.     retParamData.midiCC      = pluginParamData.midiCC;

  1463.     retParamData.midiChannel = pluginParamData.midiChannel;

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

  1465. }

  1466. 

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

  1468. {

  1469.     static ParameterRanges retParamRanges;

  1470. 

  1471.     // reset

  1472.     retParamRanges.def       = 0.0f;

  1473.     retParamRanges.min       = 0.0f;

  1474.     retParamRanges.max       = 1.0f;

  1475.     retParamRanges.step      = 0.01f;

  1476.     retParamRanges.stepSmall = 0.0001f;

  1477.     retParamRanges.stepLarge = 0.1f;

  1478. 

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

  1480. 

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

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

  1483. 

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

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

  1486. 

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

  1488.     retParamRanges.def       = pluginParamRanges.def;

  1489.     retParamRanges.min       = pluginParamRanges.min;

  1490.     retParamRanges.max       = pluginParamRanges.max;

  1491.     retParamRanges.step      = pluginParamRanges.step;

  1492.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1493.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1494.     return &pluginParamRanges;

  1495. }

  1496. 

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

  1498. {

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

  1500. 

  1501.     // reset

  1502.     retMidiProgData.bank    = 0;

  1503.     retMidiProgData.program = 0;

  1504. 

  1505.     if (retMidiProgData.name != gNullCharPtr)

  1506.     {

  1507.         delete[] retMidiProgData.name;

  1508.         retMidiProgData.name = gNullCharPtr;

  1509.     }

  1510. 

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

  1512. 

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

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

  1515. 

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

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

  1518. 

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

  1520.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1521.     retMidiProgData.program = pluginMidiProgData.program;

  1522. 

  1523.     if (pluginMidiProgData.name != nullptr)

  1524.     {

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

  1526.         checkStringPtr(retMidiProgData.name);

  1527.     }

  1528.     else

  1529.     {

  1530.         retMidiProgData.name = gNullCharPtr;

  1531.     }

  1532. 

  1533.     return &retMidiProgData;

  1534. }

  1535. 

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

  1537. {

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

  1539. 

  1540.     // reset

  1541.     if (retCustomData.type != gNullCharPtr)

  1542.     {

  1543.         delete[] retCustomData.type;

  1544.         retCustomData.type = gNullCharPtr;

  1545.     }

  1546. 

  1547.     if (retCustomData.key != gNullCharPtr)

  1548.     {

  1549.         delete[] retCustomData.key;

  1550.         retCustomData.key = gNullCharPtr;

  1551.     }

  1552. 

  1553.     if (retCustomData.value != gNullCharPtr)

  1554.     {

  1555.         delete[] retCustomData.value;

  1556.         retCustomData.value = gNullCharPtr;

  1557.     }

  1558. 

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

  1560. 

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

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

  1563. 

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

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

  1566. 

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

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

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

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

  1571.     checkStringPtr(retCustomData.type);

  1572.     checkStringPtr(retCustomData.key);

  1573.     checkStringPtr(retCustomData.value);

  1574.     return &retCustomData;

  1575. }

  1576. 

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

  1578. {

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

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

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

  1582. 

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

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

  1585. 

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

  1587. 

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

  1589. 

  1590.     if (count == 0)

  1591.         return gNullCharPtr;

  1592. 

  1593.     static CarlaString customDataValue;

  1594. 

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

  1596.     {

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

  1598. 

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

  1600.             continue;

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

  1602.             continue;

  1603. 

  1604.         customDataValue = pluginCustomData.value;

  1605.         return customDataValue.buffer();

  1606.     }

  1607. 

  1608.     return gNullCharPtr;

  1609. }

  1610. 

  1611. const char* carla_get_chunk_data(uint pluginId)

  1612. {

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

  1614. 

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

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

  1617. 

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

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

  1620. 

  1621.     void* data = nullptr;

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

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

  1624. 

  1625.     static CarlaString chunkData;

  1626. 

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

  1628.     return chunkData.buffer();

  1629. }

  1630. 

  1631. // --------------------------------------------------------------------------------------------------------------------

  1632. 

  1633. uint32_t carla_get_parameter_count(uint pluginId)

  1634. {

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

  1636. 

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

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

  1639. 

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

  1641.     return plugin->getParameterCount();

  1642. }

  1643. 

  1644. uint32_t carla_get_program_count(uint pluginId)

  1645. {

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

  1647. 

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

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

  1650. 

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

  1652.     return plugin->getProgramCount();

  1653. }

  1654. 

  1655. uint32_t carla_get_midi_program_count(uint pluginId)

  1656. {

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

  1658. 

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

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

  1661. 

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

  1663.     return plugin->getMidiProgramCount();

  1664. }

  1665. 

  1666. uint32_t carla_get_custom_data_count(uint pluginId)

  1667. {

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

  1669. 

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

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

  1672. 

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

  1674.     return plugin->getCustomDataCount();

  1675. }

  1676. 

  1677. // --------------------------------------------------------------------------------------------------------------------

  1678. 

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

  1680. {

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

  1682. 

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

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

  1685. 

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

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

  1688. 

  1689.     static char textBuf[STR_MAX+1];

  1690.     carla_zeroChars(textBuf, STR_MAX+1);

  1691. 

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

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

  1694. 

  1695.     return textBuf;

  1696. }

  1697. 

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

  1699. {

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

  1701. 

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

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

  1704. 

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

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

  1707. 

  1708.     static char programName[STR_MAX+1];

  1709.     carla_zeroChars(programName, STR_MAX+1);

  1710. 

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

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

  1713. 

  1714.     return programName;

  1715. }

  1716. 

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

  1718. {

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

  1720. 

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

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

  1723. 

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

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

  1726. 

  1727.     static char midiProgramName[STR_MAX+1];

  1728.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1729. 

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

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

  1732. 

  1733.     return midiProgramName;

  1734. }

  1735. 

  1736. const char* carla_get_real_plugin_name(uint pluginId)

  1737. {

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

  1739. 

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

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

  1742. 

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

  1744.     static char realPluginName[STR_MAX+1];

  1745.     carla_zeroChars(realPluginName, STR_MAX+1);

  1746. 

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

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

  1749. 

  1750.     return realPluginName;

  1751. }

  1752. 

  1753. // --------------------------------------------------------------------------------------------------------------------

  1754. 

  1755. int32_t carla_get_current_program_index(uint pluginId)

  1756. {

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

  1758. 

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

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

  1761. 

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

  1763.     return plugin->getCurrentProgram();

  1764. }

  1765. 

  1766. int32_t carla_get_current_midi_program_index(uint pluginId)

  1767. {

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

  1769. 

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

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

  1772. 

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

  1774.     return plugin->getCurrentMidiProgram();

  1775. }

  1776. 

  1777. // --------------------------------------------------------------------------------------------------------------------

  1778. 

  1779. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1780. {

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

  1782. 

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

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

  1785. 

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

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

  1788. 

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

  1790. }

  1791. 

  1792. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1793. {

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

  1795. 

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

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

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

  1799. 

  1800.     return plugin->getParameterValue(parameterId);

  1801. }

  1802. 

  1803. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1804. {

  1805. #ifdef BUILD_BRIDGE

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

  1807. #else

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

  1809. #endif

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

  1811. 

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

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

  1814. 

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

  1816.     return plugin->getInternalParameterValue(parameterId);

  1817. }

  1818. 

  1819. // --------------------------------------------------------------------------------------------------------------------

  1820. 

  1821. const float* carla_get_peak_values(uint pluginId)

  1822. {

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

  1824. 

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

  1826. }

  1827. 

  1828. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1829. {

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

  1831. 

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

  1833. }

  1834. 

  1835. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1836. {

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

  1838. 

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

  1840. }

  1841. 

  1842. // --------------------------------------------------------------------------------------------------------------------

  1843. 

  1844. CARLA_BACKEND_START_NAMESPACE

  1845. 

  1846. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1847. // defined in CarlaPluginInternal.cpp

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

  1849. #endif

  1850. 

  1851. // defined in CarlaPluginLV2.cpp

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

  1853. 

  1854. CARLA_BACKEND_END_NAMESPACE

  1855. 

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

  1857. {

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

  1859. 

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

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

  1862. 

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

  1864. 

  1865.     switch (plugin->getType())

  1866.     {

  1867. #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH

  1868.     case CB::PLUGIN_INTERNAL:

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

  1870. #endif

  1871.     case CB::PLUGIN_LV2:

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

  1873.     default:

  1874.         return nullptr;

  1875.     }

  1876. }

  1877. 

  1878. // --------------------------------------------------------------------------------------------------------------------

  1879. 

  1880. void carla_set_active(uint pluginId, bool onOff)

  1881. {

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

  1883. 

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

  1885.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1886. 

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

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

  1889. }

  1890. 

  1891. #ifndef BUILD_BRIDGE

  1892. void carla_set_drywet(uint pluginId, float value)

  1893. {

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

  1895. 

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

  1897.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1898. 

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

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

  1901. }

  1902. 

  1903. void carla_set_volume(uint pluginId, float value)

  1904. {

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

  1906. 

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

  1908.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1909. 

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

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

  1912. }

  1913. 

  1914. void carla_set_balance_left(uint pluginId, float value)

  1915. {

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

  1917. 

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

  1919.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1920. 

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

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

  1923. }

  1924. 

  1925. void carla_set_balance_right(uint pluginId, float value)

  1926. {

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

  1928. 

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

  1930.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1931. 

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

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

  1934. }

  1935. 

  1936. void carla_set_panning(uint pluginId, float value)

  1937. {

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

  1939. 

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

  1941.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1942. 

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

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

  1945. }

  1946. 

  1947. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1948. {

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

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

  1951. 

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

  1953.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1954. 

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

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

  1957. }

  1958. #endif

  1959. 

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

  1961. {

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

  1963. 

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

  1965.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1966. 

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

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

  1969. }

  1970. 

  1971. // --------------------------------------------------------------------------------------------------------------------

  1972. 

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

  1974. {

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

  1976. 

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

  1978.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1979. 

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

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

  1982. 

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

  1984. }

  1985. 

  1986. #ifndef BUILD_BRIDGE

  1987. void carla_set_parameter_cv_controlled(uint pluginId, uint32_t parameterId, bool cv_controlled)

  1988. {

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

  1990. 

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

  1992.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1993. 

  1994.     carla_debug("carla_set_parameter_cv_controlled(%u, %u, %s)", pluginId, parameterId, bool2str(cv_controlled));

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

  1996. 

  1997.     return plugin->setParameterAsCvControl(parameterId, cv_controlled, true, false);

  1998. }

  1999. 

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

  2001. {

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

  2003.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  2004. 

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

  2006.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2007. 

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

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

  2010. 

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

  2012. }

  2013. 

  2014. void carla_set_parameter_midi_cc(uint pluginId, uint32_t parameterId, int16_t cc)

  2015. {

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

  2017.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < MAX_MIDI_CONTROL,);

  2018. 

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

  2020.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2021. 

  2022.     carla_debug("carla_set_parameter_midi_cc(%i, %i, %i)", pluginId, parameterId, cc);

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

  2024. 

  2025.     return plugin->setParameterMidiCC(parameterId, cc, true, false);

  2026. }

  2027. 

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

  2029. {

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

  2031. 

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

  2033.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2034. 

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

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

  2037. 

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

  2039. }

  2040. 

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

  2042. {

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

  2044. 

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

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

  2047. }

  2048. #endif

  2049. 

  2050. // --------------------------------------------------------------------------------------------------------------------

  2051. 

  2052. void carla_set_program(uint pluginId, uint32_t programId)

  2053. {

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

  2055. 

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

  2057.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2058. 

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

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

  2061. 

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

  2063. }

  2064. 

  2065. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2066. {

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

  2068. 

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

  2070.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2071. 

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

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

  2074. 

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

  2076. }

  2077. 

  2078. // --------------------------------------------------------------------------------------------------------------------

  2079. 

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

  2081. {

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

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

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

  2085.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  2086. 

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

  2088.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2089. 

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

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

  2092. }

  2093. 

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

  2095. {

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

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

  2098. 

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

  2100.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2101. 

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

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

  2104. 

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

  2106. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  2108. #else

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

  2110. #endif

  2111. }

  2112. 

  2113. // --------------------------------------------------------------------------------------------------------------------

  2114. 

  2115. void carla_prepare_for_save(uint pluginId)

  2116. {

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

  2118. 

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

  2120.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2121. 

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

  2123.     return plugin->prepareForSave();

  2124. }

  2125. 

  2126. void carla_reset_parameters(uint pluginId)

  2127. {

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

  2129. 

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

  2131.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2132. 

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

  2134.     return plugin->resetParameters();

  2135. }

  2136. 

  2137. void carla_randomize_parameters(uint pluginId)

  2138. {

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

  2140. 

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

  2142.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2143. 

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

  2145.     return plugin->randomizeParameters();

  2146. }

  2147. 

  2148. #ifndef BUILD_BRIDGE

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

  2150. {

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

  2152. 

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

  2154.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2155. 

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

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

  2158. }

  2159. #endif

  2160. 

  2161. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2162. {

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

  2164. 

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

  2166.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2167. 

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

  2169.     return plugin->showCustomUI(yesNo);

  2170. }

  2171. 

  2172. // --------------------------------------------------------------------------------------------------------------------

  2173. 

  2174. uint32_t carla_get_buffer_size()

  2175. {

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

  2177. 

  2178.     carla_debug("carla_get_buffer_size()");

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

  2180. }

  2181. 

  2182. double carla_get_sample_rate()

  2183. {

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

  2185. 

  2186.     carla_debug("carla_get_sample_rate()");

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

  2188. }

  2189. 

  2190. // --------------------------------------------------------------------------------------------------------------------

  2191. 

  2192. const char* carla_get_last_error()

  2193. {

  2194.     carla_debug("carla_get_last_error()");

  2195. 

  2196.     if (gStandalone.engine != nullptr)

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

  2198. 

  2199.     return gStandalone.lastError;

  2200. }

  2201. 

  2202. const char* carla_get_host_osc_url_tcp()

  2203. {

  2204.     carla_debug("carla_get_host_osc_url_tcp()");

  2205. 

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

  2207.     if (gStandalone.engine == nullptr)

  2208.     {

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

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

  2211.         return gNullCharPtr;

  2212.     }

  2213. 

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

  2215. 

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

  2217.         return path;

  2218. 

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

  2220.     return notAvailable;

  2221. #else

  2222.     return gNullCharPtr;

  2223. #endif

  2224. }

  2225. 

  2226. const char* carla_get_host_osc_url_udp()

  2227. {

  2228.     carla_debug("carla_get_host_osc_url_udp()");

  2229. 

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

  2231.     if (gStandalone.engine == nullptr)

  2232.     {

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

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

  2235.         return gNullCharPtr;

  2236.     }

  2237. 

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

  2239. 

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

  2241.         return path;

  2242. 

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

  2244.     return notAvailable;

  2245. #else

  2246.     return gNullCharPtr;

  2247. #endif

  2248. }

  2249. 

  2250. // --------------------------------------------------------------------------------------------------------------------

  2251. 

  2252. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2253. #include "CarlaPluginUI.cpp"

  2254. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2255. 

  2256. #include "CarlaDssiUtils.cpp"

  2257. #include "CarlaMacUtils.cpp"

  2258. #include "CarlaPatchbayUtils.cpp"

  2259. #include "CarlaPipeUtils.cpp"

  2260. #include "CarlaStateUtils.cpp"

  2261. 

  2262. // --------------------------------------------------------------------------------------------------------------------