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

1959 lines
71KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2018 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. 

  30. #ifdef BUILD_BRIDGE

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

  32. #else

  33. # include "CarlaLogThread.hpp"

  34. #endif

  35. 

  36. namespace CB = CarlaBackend;

  37. using CB::EngineOptions;

  38. 

  39. // --------------------------------------------------------------------------------------------------------------------

  40. // Single, standalone engine

  41. 

  42. struct CarlaBackendStandalone {

  43.     CarlaEngine*       engine;

  44.     EngineCallbackFunc engineCallback;

  45.     void*              engineCallbackPtr;

  46. #ifndef BUILD_BRIDGE

  47.     EngineOptions      engineOptions;

  48.     CarlaLogThread     logThread;

  49.     bool               logThreadEnabled;

  50. #endif

  51. 

  52.     FileCallbackFunc fileCallback;

  53.     void*            fileCallbackPtr;

  54. 

  55.     CarlaString lastError;

  56. 

  57.     CarlaBackendStandalone() noexcept

  58.         : engine(nullptr),

  59.           engineCallback(nullptr),

  60.           engineCallbackPtr(nullptr),

  61. #ifndef BUILD_BRIDGE

  62.           engineOptions(),

  63.           logThread(),

  64.           logThreadEnabled(false),

  65. #endif

  66.           fileCallback(nullptr),

  67.           fileCallbackPtr(nullptr),

  68.           lastError() {}

  69. 

  70.     ~CarlaBackendStandalone() noexcept

  71.     {

  72.         CARLA_SAFE_ASSERT(engine == nullptr);

  73.     }

  74. 

  75.     CARLA_PREVENT_HEAP_ALLOCATION

  76.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  77. };

  78. 

  79. CarlaBackendStandalone gStandalone;

  80. 

  81. // --------------------------------------------------------------------------------------------------------------------

  82. // API

  83. 

  84. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  85. #include "CarlaHostCommon.cpp"

  86. 

  87. // --------------------------------------------------------------------------------------------------------------------

  88. 

  89. uint carla_get_engine_driver_count()

  90. {

  91.     carla_debug("carla_get_engine_driver_count()");

  92. 

  93.     return CarlaEngine::getDriverCount();

  94. }

  95. 

  96. const char* carla_get_engine_driver_name(uint index)

  97. {

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

  99. 

  100.     return CarlaEngine::getDriverName(index);

  101. }

  102. 

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

  104. {

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

  106. 

  107.     return CarlaEngine::getDriverDeviceNames(index);

  108. }

  109. 

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

  111. {

  112.     CARLA_SAFE_ASSERT_RETURN(name != nullptr && name[0] != '\0', nullptr);

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

  114. 

  115.     if (const EngineDriverDeviceInfo* const ret = CarlaEngine::getDriverDeviceInfo(index, name))

  116.     {

  117.         static EngineDriverDeviceInfo retDevInfo;

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

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

  120. 

  121.         retDevInfo.hints       = ret->hints;

  122.         retDevInfo.bufferSizes = (ret->bufferSizes != nullptr) ? ret->bufferSizes : nullBufferSizes;

  123.         retDevInfo.sampleRates = (ret->sampleRates != nullptr) ? ret->sampleRates : nullSampleRates;

  124.         return &retDevInfo;

  125.     }

  126. 

  127.     return nullptr;

  128. }

  129. 

  130. // --------------------------------------------------------------------------------------------------------------------

  131. 

  132. CarlaEngine* carla_get_engine()

  133. {

  134.     carla_debug("carla_get_engine()");

  135. 

  136.     return gStandalone.engine;

  137. }

  138. 

  139. // --------------------------------------------------------------------------------------------------------------------

  140. 

  141. static void carla_engine_init_common()

  142. {

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

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

  145. 

  146. #ifdef BUILD_BRIDGE

  147.     using water::File;

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

  149. 

  150.     /*

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

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

  153. 

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

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

  156. 

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

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

  159.     */

  160. 

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

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

  163. 

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

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

  166. 

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

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

  169. 

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

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

  172. 

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

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

  175. 

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

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

  178. 

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

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

  181. 

  182.     if (const char* const pathGIG = std::getenv("ENGINE_OPTION_PLUGIN_PATH_GIG"))

  183.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_GIG, pathGIG);

  184. 

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

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

  187. 

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

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

  190. 

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

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

  193.     else

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

  195. 

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

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

  198.     else

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

  200. 

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

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

  203. 

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

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

  206. #else

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

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

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

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

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

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

  213.     gStandalone.engine->setOption(CB::ENGINE_OPTION_AUDIO_NUM_PERIODS,     static_cast<int>(gStandalone.engineOptions.audioNumPeriods),  nullptr);

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

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

  216. 

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

  218. 

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

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

  221. 

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

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

  224. 

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

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

  227. 

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

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

  230. 

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

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

  233. 

  234.     if (gStandalone.engineOptions.pathGIG != nullptr)

  235.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,       CB::PLUGIN_GIG, gStandalone.engineOptions.pathGIG);

  236. 

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

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

  239. 

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

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

  242. 

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

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

  245. 

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

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

  248. 

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

  250. 

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

  252.     {

  253.         char strBuf[STR_MAX+1];

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

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

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

  257.     }

  258.     else

  259.     {

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

  261.     }

  262. 

  263. # ifndef CARLA_OS_WIN

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

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

  266. 

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

  268. 

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

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

  271. 

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

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

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

  275. # endif

  276. #endif

  277. }

  278. 

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

  280. {

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

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

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

  284. 

  285.     if (gStandalone.engine != nullptr)

  286.     {

  287.         carla_stderr2("Engine is already running");

  288.         gStandalone.lastError = "Engine is already running";

  289.         return false;

  290.     }

  291. 

  292. #ifdef CARLA_OS_WIN

  293.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  294. #endif

  295. 

  296.     gStandalone.engine = CarlaEngine::newDriverByName(driverName);

  297. 

  298.     if (gStandalone.engine == nullptr)

  299.     {

  300.         carla_stderr2("The seleted audio driver is not available");

  301.         gStandalone.lastError = "The seleted audio driver is not available";

  302.         return false;

  303.     }

  304. 

  305. #ifdef BUILD_BRIDGE

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

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

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

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

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

  311. #else

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

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

  314. #endif

  315. 

  316.     carla_engine_init_common();

  317. 

  318.     if (gStandalone.engine->init(clientName))

  319.     {

  320. #ifndef BUILD_BRIDGE

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

  322.             gStandalone.logThread.init();

  323. #endif

  324.         gStandalone.lastError = "No error";

  325.         return true;

  326.     }

  327.     else

  328.     {

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

  330.         delete gStandalone.engine;

  331.         gStandalone.engine = nullptr;

  332.         return false;

  333.     }

  334. }

  335. 

  336. #ifdef BUILD_BRIDGE

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

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

  339. {

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

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

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

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

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

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

  346. 

  347.     if (gStandalone.engine != nullptr)

  348.     {

  349.         carla_stderr2("Engine is already running");

  350.         gStandalone.lastError = "Engine is already running";

  351.         return false;

  352.     }

  353. 

  354.     gStandalone.engine = CarlaEngine::newBridge(audioBaseName, rtClientBaseName, nonRtClientBaseName, nonRtServerBaseName);

  355. 

  356.     if (gStandalone.engine == nullptr)

  357.     {

  358.         carla_stderr2("The seleted audio driver is not available!");

  359.         gStandalone.lastError = "The seleted audio driver is not available!";

  360.         return false;

  361.     }

  362. 

  363.     carla_engine_init_common();

  364. 

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

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

  367. 

  368.     if (gStandalone.engine->init(clientName))

  369.     {

  370.         gStandalone.lastError = "No error";

  371.         return true;

  372.     }

  373.     else

  374.     {

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

  376.         delete gStandalone.engine;

  377.         gStandalone.engine = nullptr;

  378.         return false;

  379.     }

  380. }

  381. #endif

  382. 

  383. bool carla_engine_close()

  384. {

  385.     carla_debug("carla_engine_close()");

  386. 

  387.     if (gStandalone.engine == nullptr)

  388.     {

  389.         carla_stderr2("carla_engine_close() failed, engine is not running");

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

  391.         return false;

  392.     }

  393. 

  394.     gStandalone.engine->setAboutToClose();

  395.     gStandalone.engine->removeAllPlugins();

  396. 

  397.     const bool closed(gStandalone.engine->close());

  398. 

  399.     if (! closed)

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

  401. 

  402.     delete gStandalone.engine;

  403.     gStandalone.engine = nullptr;

  404. 

  405. #ifndef BUILD_BRIDGE

  406.     gStandalone.logThread.stop();

  407. #endif

  408. 

  409.     return closed;

  410. }

  411. 

  412. void carla_engine_idle()

  413. {

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

  415. 

  416.     gStandalone.engine->idle();

  417. }

  418. 

  419. bool carla_is_engine_running()

  420. {

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

  422. }

  423. 

  424. bool carla_set_engine_about_to_close()

  425. {

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

  427.     carla_debug("carla_set_engine_about_to_close()");

  428. 

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

  430. }

  431. 

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

  433. {

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

  435. 

  436.     gStandalone.engineCallback    = func;

  437.     gStandalone.engineCallbackPtr = ptr;

  438. 

  439. #ifndef BUILD_BRIDGE

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

  441. #endif

  442. 

  443.     if (gStandalone.engine != nullptr)

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

  445. }

  446. 

  447. #ifndef BUILD_BRIDGE

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

  449. {

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

  451. 

  452.     switch (option)

  453.     {

  454.     case CB::ENGINE_OPTION_DEBUG:

  455.         break;

  456. 

  457.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  460.         break;

  461. 

  462.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  465.         delete[] gStandalone.engineOptions.transportExtra;

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

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

  468.         else

  469.             gStandalone.engineOptions.transportExtra = nullptr;

  470.         break;

  471. 

  472.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  475.         break;

  476. 

  477.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  480.         break;

  481. 

  482.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  485.         break;

  486. 

  487.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  490.         break;

  491. 

  492.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  493.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  495.         break;

  496. 

  497.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  498.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  500.         break;

  501. 

  502.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

  503.         CARLA_SAFE_ASSERT_RETURN(value >= 2 && value <= 3,);

  504.         gStandalone.engineOptions.audioNumPeriods = static_cast<uint>(value);

  505.         break;

  506. 

  507.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  508.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  510.         break;

  511. 

  512.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  513.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  515.         break;

  516. 

  517.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  518.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  519. 

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

  521.             delete[] gStandalone.engineOptions.audioDevice;

  522. 

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

  524.         break;

  525. 

  526.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  529.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  530. 

  531.         switch (value)

  532.         {

  533.         case CB::PLUGIN_LADSPA:

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

  535.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  537.             break;

  538.         case CB::PLUGIN_DSSI:

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

  540.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  542.             break;

  543.         case CB::PLUGIN_LV2:

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

  545.                 delete[] gStandalone.engineOptions.pathLV2;

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

  547.             break;

  548.         case CB::PLUGIN_VST2:

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

  550.                 delete[] gStandalone.engineOptions.pathVST2;

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

  552.             break;

  553.         case CB::PLUGIN_GIG:

  554.             if (gStandalone.engineOptions.pathGIG != nullptr)

  555.                 delete[] gStandalone.engineOptions.pathGIG;

  556.             gStandalone.engineOptions.pathGIG = carla_strdup_safe(valueStr);

  557.             break;

  558.         case CB::PLUGIN_SF2:

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

  560.                 delete[] gStandalone.engineOptions.pathSF2;

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

  562.             break;

  563.         case CB::PLUGIN_SFZ:

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

  565.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  567.             break;

  568.         }

  569.         break;

  570. 

  571.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  573. 

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

  575.             delete[] gStandalone.engineOptions.binaryDir;

  576. 

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

  578.         break;

  579. 

  580.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  582. 

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

  584.             delete[] gStandalone.engineOptions.resourceDir;

  585. 

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

  587.         break;

  588. 

  589.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  592.         break;

  593. 

  594.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  597.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  599.     }   break;

  600. 

  601. #ifndef CARLA_OS_WIN

  602.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  604. 

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

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

  607. 

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

  609.         break;

  610. 

  611.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  614.         break;

  615. 

  616.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  618. 

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

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

  621. 

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

  623.         break;

  624. 

  625.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  628.         break;

  629. 

  630.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  633.         break;

  634. 

  635.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  638.         break;

  639. #endif

  640. 

  641.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  643.         break;

  644.     }

  645. 

  646.     if (gStandalone.engine != nullptr)

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

  648. }

  649. #endif

  650. 

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

  652. {

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

  654. 

  655.     gStandalone.fileCallback    = func;

  656.     gStandalone.fileCallbackPtr = ptr;

  657. 

  658.     if (gStandalone.engine != nullptr)

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

  660. }

  661. 

  662. // --------------------------------------------------------------------------------------------------------------------

  663. 

  664. bool carla_load_file(const char* filename)

  665. {

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

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

  668. 

  669.     if (gStandalone.engine != nullptr)

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

  671. 

  672.     carla_stderr2("carla_load_file() failed, engine is not running");

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

  674.     return false;

  675. }

  676. 

  677. bool carla_load_project(const char* filename)

  678. {

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

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

  681. 

  682.     if (gStandalone.engine != nullptr)

  683.         return gStandalone.engine->loadProject(filename);

  684. 

  685.     carla_stderr2("carla_load_project() failed, engine is not running");

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

  687.     return false;

  688. }

  689. 

  690. bool carla_save_project(const char* filename)

  691. {

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

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

  694. 

  695.     if (gStandalone.engine != nullptr)

  696.         return gStandalone.engine->saveProject(filename);

  697. 

  698.     carla_stderr2("carla_save_project() failed, engine is not initialized");

  699.     gStandalone.lastError = "Engine is not initialized";

  700.     return false;

  701. }

  702. 

  703. #ifndef BUILD_BRIDGE

  704. // --------------------------------------------------------------------------------------------------------------------

  705. 

  706. bool carla_patchbay_connect(uint groupIdA, uint portIdA, uint groupIdB, uint portIdB)

  707. {

  708.     carla_debug("carla_patchbay_connect(%u, %u, %u, %u)", groupIdA, portIdA, groupIdB, portIdB);

  709. 

  710.     if (gStandalone.engine != nullptr)

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

  712. 

  713.     carla_stderr2("carla_patchbay_connect() failed, engine is not running");

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

  715.     return false;

  716. }

  717. 

  718. bool carla_patchbay_disconnect(uint connectionId)

  719. {

  720.     carla_debug("carla_patchbay_disconnect(%i)", connectionId);

  721. 

  722.     if (gStandalone.engine != nullptr)

  723.         return gStandalone.engine->patchbayDisconnect(connectionId);

  724. 

  725.     carla_stderr2("carla_patchbay_disconnect() failed, engine is not running");

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

  727.     return false;

  728. }

  729. 

  730. bool carla_patchbay_refresh(bool external)

  731. {

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

  733. 

  734.     if (gStandalone.engine != nullptr)

  735.         return gStandalone.engine->patchbayRefresh(external);

  736. 

  737.     carla_stderr2("carla_patchbay_refresh() failed, engine is not running");

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

  739.     return false;

  740. }

  741. 

  742. // --------------------------------------------------------------------------------------------------------------------

  743. 

  744. void carla_transport_play()

  745. {

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

  747.     carla_debug("carla_transport_play()");

  748. 

  749.     gStandalone.engine->transportPlay();

  750. }

  751. 

  752. void carla_transport_pause()

  753. {

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

  755.     carla_debug("carla_transport_pause()");

  756. 

  757.     gStandalone.engine->transportPause();

  758. }

  759. 

  760. void carla_transport_bpm(double bpm)

  761. {

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

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

  764. 

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

  766. }

  767. 

  768. void carla_transport_relocate(uint64_t frame)

  769. {

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

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

  772. 

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

  774. }

  775. 

  776. uint64_t carla_get_current_transport_frame()

  777. {

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

  779. 

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

  781.     return timeInfo.frame;

  782. }

  783. 

  784. const CarlaTransportInfo* carla_get_transport_info()

  785. {

  786.     static CarlaTransportInfo retInfo;

  787.     carla_zeroStruct(retInfo);

  788. 

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

  790. 

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

  792. 

  793.     retInfo.playing = timeInfo.playing;

  794.     retInfo.frame   = timeInfo.frame;

  795. 

  796.     if (timeInfo.bbt.valid)

  797.     {

  798.         retInfo.bar  = timeInfo.bbt.bar;

  799.         retInfo.beat = timeInfo.bbt.beat;

  800.         retInfo.tick = timeInfo.bbt.tick;

  801.         retInfo.bpm  = timeInfo.bbt.beatsPerMinute;

  802.     }

  803. 

  804.     return &retInfo;

  805. }

  806. #endif

  807. 

  808. // --------------------------------------------------------------------------------------------------------------------

  809. 

  810. uint32_t carla_get_current_plugin_count()

  811. {

  812.     if (gStandalone.engine != nullptr)

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

  814. 

  815.     return 0;

  816. }

  817. 

  818. uint32_t carla_get_max_plugin_number()

  819. {

  820.     if (gStandalone.engine != nullptr)

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

  822. 

  823.     return 0;

  824. }

  825. 

  826. // --------------------------------------------------------------------------------------------------------------------

  827. 

  828. bool carla_add_plugin(BinaryType btype, PluginType ptype,

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

  830.                       const void* extraPtr, uint options)

  831. {

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

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

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

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

  836. 

  837.     if (gStandalone.engine != nullptr)

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

  839. 

  840.     carla_stderr2("carla_add_plugin() failed, engine is not running");

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

  842.     return false;

  843. }

  844. 

  845. bool carla_remove_plugin(uint pluginId)

  846. {

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

  848. 

  849.     if (gStandalone.engine != nullptr)

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

  851. 

  852.     carla_stderr2("carla_remove_plugin() failed, engine is not running");

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

  854.     return false;

  855. }

  856. 

  857. bool carla_remove_all_plugins()

  858. {

  859.     carla_debug("carla_remove_all_plugins()");

  860. 

  861.     if (gStandalone.engine != nullptr)

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

  863. 

  864.     carla_stderr2("carla_remove_all_plugins() failed, engine is not running");

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

  866.     return false;

  867. }

  868. 

  869. #ifndef BUILD_BRIDGE

  870. const char* carla_rename_plugin(uint pluginId, const char* newName)

  871. {

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

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

  874. 

  875.     if (gStandalone.engine != nullptr)

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

  877. 

  878.     carla_stderr2("carla_rename_plugin() failed, engine is not running");

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

  880.     return nullptr;

  881. }

  882. 

  883. bool carla_clone_plugin(uint pluginId)

  884. {

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

  886. 

  887.     if (gStandalone.engine != nullptr)

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

  889. 

  890.     carla_stderr2("carla_clone_plugin() failed, engine is not running");

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

  892.     return false;

  893. }

  894. 

  895. bool carla_replace_plugin(uint pluginId)

  896. {

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

  898. 

  899.     if (gStandalone.engine != nullptr)

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

  901. 

  902.     carla_stderr2("carla_replace_plugin() failed, engine is not running");

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

  904.     return false;

  905. }

  906. 

  907. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  908. {

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

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

  911. 

  912.     if (gStandalone.engine != nullptr)

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

  914. 

  915.     carla_stderr2("carla_switch_plugins() failed, engine is not running");

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

  917.     return false;

  918. }

  919. #endif

  920. 

  921. // --------------------------------------------------------------------------------------------------------------------

  922. 

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

  924. {

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

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

  927. 

  928.     if (gStandalone.engine == nullptr || ! gStandalone.engine->isRunning())

  929.     {

  930.         carla_stderr2("carla_load_plugin_state() failed, engine is not running");

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

  932.         return false;

  933.     }

  934. 

  935.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  936.         return plugin->loadStateFromFile(filename);

  937. 

  938.     carla_stderr2("carla_load_plugin_state(%i, \"%s\") failed, could not find plugin", pluginId, filename);

  939.     return false;

  940. }

  941. 

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

  943. {

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

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

  946. 

  947.     if (gStandalone.engine == nullptr)

  948.     {

  949.         carla_stderr2("carla_save_plugin_state() failed, engine is not initialized");

  950.         gStandalone.lastError = "Engine is not initialized";

  951.         return false;

  952.     }

  953. 

  954.     // allow to save even if engine isn't running

  955. 

  956.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  957.         return plugin->saveStateToFile(filename);

  958. 

  959.     carla_stderr2("carla_save_plugin_state(%i, \"%s\") failed, could not find plugin", pluginId, filename);

  960.     return false;

  961. }

  962. 

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

  964. {

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

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

  967. 

  968.     if (gStandalone.engine == nullptr)

  969.     {

  970.         carla_stderr2("carla_export_plugin_lv2() failed, engine is not initialized");

  971.         gStandalone.lastError = "Engine is not initialized";

  972.         return false;

  973.     }

  974. 

  975.     // allow to export even if engine isn't running

  976. 

  977.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  978.         return plugin->exportAsLV2(lv2path);

  979. 

  980.     carla_stderr2("carla_export_plugin_lv2(%i, \"%s\") failed, could not find plugin", pluginId, lv2path);

  981.     return false;

  982. }

  983. 

  984. // --------------------------------------------------------------------------------------------------------------------

  985. 

  986. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  987. {

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

  989. 

  990.     static CarlaPluginInfo retInfo;

  991. 

  992.     // reset

  993.     retInfo.type             = CB::PLUGIN_NONE;

  994.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  995.     retInfo.hints            = 0x0;

  996.     retInfo.optionsAvailable = 0x0;

  997.     retInfo.optionsEnabled   = 0x0;

  998.     retInfo.filename         = gNullCharPtr;

  999.     retInfo.name             = gNullCharPtr;

  1000.     retInfo.iconName         = gNullCharPtr;

  1001.     retInfo.uniqueId         = 0;

  1002. 

  1003.     // cleanup

  1004.     if (retInfo.label != gNullCharPtr)

  1005.     {

  1006.         delete[] retInfo.label;

  1007.         retInfo.label = gNullCharPtr;

  1008.     }

  1009. 

  1010.     if (retInfo.maker != gNullCharPtr)

  1011.     {

  1012.         delete[] retInfo.maker;

  1013.         retInfo.maker = gNullCharPtr;

  1014.     }

  1015. 

  1016.     if (retInfo.copyright != gNullCharPtr)

  1017.     {

  1018.         delete[] retInfo.copyright;

  1019.         retInfo.copyright = gNullCharPtr;

  1020.     }

  1021. 

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

  1023. 

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

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

  1026. 

  1027.     char strBuf[STR_MAX+1];

  1028. 

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

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

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

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

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

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

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

  1036. 

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

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

  1039. 

  1040.     carla_zeroChars(strBuf, STR_MAX+1);

  1041.     plugin->getLabel(strBuf);

  1042.     retInfo.label = carla_strdup_safe(strBuf);

  1043. 

  1044.     carla_zeroChars(strBuf, STR_MAX+1);

  1045.     plugin->getMaker(strBuf);

  1046.     retInfo.maker = carla_strdup_safe(strBuf);

  1047. 

  1048.     carla_zeroChars(strBuf, STR_MAX+1);

  1049.     plugin->getCopyright(strBuf);

  1050.     retInfo.copyright = carla_strdup_safe(strBuf);

  1051. 

  1052.     checkStringPtr(retInfo.filename);

  1053.     checkStringPtr(retInfo.name);

  1054.     checkStringPtr(retInfo.iconName);

  1055.     checkStringPtr(retInfo.label);

  1056.     checkStringPtr(retInfo.maker);

  1057.     checkStringPtr(retInfo.copyright);

  1058. 

  1059.     return &retInfo;

  1060. }

  1061. 

  1062. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1063. {

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

  1065. 

  1066.     static CarlaPortCountInfo retInfo;

  1067.     carla_zeroStruct(retInfo);

  1068. 

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

  1070. 

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

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

  1073. 

  1074.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1075.     {

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

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

  1078.         return &retInfo;

  1079.     }

  1080. 

  1081.     carla_stderr2("carla_get_audio_port_count_info(%i) - could not find plugin", pluginId);

  1082.     return &retInfo;

  1083. }

  1084. 

  1085. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1086. {

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

  1088. 

  1089.     static CarlaPortCountInfo retInfo;

  1090.     carla_zeroStruct(retInfo);

  1091. 

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

  1093. 

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

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

  1096. 

  1097.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1098.     {

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

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

  1101.         return &retInfo;

  1102.     }

  1103. 

  1104.     carla_stderr2("carla_get_midi_port_count_info(%i) - could not find plugin", pluginId);

  1105.     return &retInfo;

  1106. }

  1107. 

  1108. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1109. {

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

  1111. 

  1112.     static CarlaPortCountInfo retInfo;

  1113.     carla_zeroStruct(retInfo);

  1114. 

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

  1116. 

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

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

  1119. 

  1120.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1121.     {

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

  1123.         return &retInfo;

  1124.     }

  1125. 

  1126.     carla_stderr2("carla_get_parameter_count_info(%i) - could not find plugin", pluginId);

  1127.     return &retInfo;

  1128. }

  1129. 

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

  1131. {

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

  1133. 

  1134.     static CarlaParameterInfo retInfo;

  1135. 

  1136.     // reset

  1137.     retInfo.scalePointCount = 0;

  1138. 

  1139.     // cleanup

  1140.     if (retInfo.name != gNullCharPtr)

  1141.     {

  1142.         delete[] retInfo.name;

  1143.         retInfo.name = gNullCharPtr;

  1144.     }

  1145. 

  1146.     if (retInfo.symbol != gNullCharPtr)

  1147.     {

  1148.         delete[] retInfo.symbol;

  1149.         retInfo.symbol = gNullCharPtr;

  1150.     }

  1151. 

  1152.     if (retInfo.unit != gNullCharPtr)

  1153.     {

  1154.         delete[] retInfo.unit;

  1155.         retInfo.unit = gNullCharPtr;

  1156.     }

  1157. 

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

  1159. 

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

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

  1162. 

  1163.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1164.     {

  1165.         if (parameterId < plugin->getParameterCount())

  1166.         {

  1167.             char strBufName[STR_MAX+1];

  1168.             char strBufSymbol[STR_MAX+1];

  1169.             char strBufUnit[STR_MAX+1];

  1170. 

  1171.             carla_zeroChars(strBufName, STR_MAX+1);

  1172.             carla_zeroChars(strBufSymbol, STR_MAX+1);

  1173.             carla_zeroChars(strBufUnit, STR_MAX+1);

  1174. 

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

  1176. 

  1177.             plugin->getParameterName(parameterId, strBufName);

  1178.             retInfo.name = carla_strdup_safe(strBufName);

  1179. 

  1180.             plugin->getParameterSymbol(parameterId, strBufSymbol);

  1181.             retInfo.symbol = carla_strdup_safe(strBufSymbol);

  1182. 

  1183.             plugin->getParameterUnit(parameterId, strBufUnit);

  1184.             retInfo.unit = carla_strdup_safe(strBufUnit);

  1185. 

  1186.             checkStringPtr(retInfo.name);

  1187.             checkStringPtr(retInfo.symbol);

  1188.             checkStringPtr(retInfo.unit);

  1189.         }

  1190.         else

  1191.             carla_stderr2("carla_get_parameter_info(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1192. 

  1193.         return &retInfo;

  1194.     }

  1195. 

  1196.     carla_stderr2("carla_get_parameter_info(%i, %i) - could not find plugin", pluginId, parameterId);

  1197.     return &retInfo;

  1198. }

  1199. 

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

  1201. {

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

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

  1204. 

  1205.     static CarlaScalePointInfo retInfo;

  1206. 

  1207.     // reset

  1208.     retInfo.value = 0.0f;

  1209. 

  1210.     // cleanup

  1211.     if (retInfo.label != gNullCharPtr)

  1212.     {

  1213.         delete[] retInfo.label;

  1214.         retInfo.label = gNullCharPtr;

  1215.     }

  1216. 

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

  1218. 

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

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

  1221. 

  1222.     if (CarlaPlugin* const plugin = gStandalone.engine->getPlugin(pluginId))

  1223.     {

  1224.         if (parameterId < plugin->getParameterCount())

  1225.         {

  1226.             if (scalePointId < plugin->getParameterScalePointCount(parameterId))

  1227.             {

  1228.                 char strBufLabel[STR_MAX+1];

  1229.                 carla_zeroChars(strBufLabel, STR_MAX+1);

  1230. 

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

  1232. 

  1233.                 plugin->getParameterScalePointLabel(parameterId, scalePointId, strBufLabel);

  1234.                 retInfo.label = carla_strdup_safe(strBufLabel);

  1235.                 checkStringPtr(retInfo.label);

  1236.             }

  1237.             else

  1238.                 carla_stderr2("carla_get_parameter_scalepoint_info(%i, %i, %i) - scalePointId out of bounds", pluginId, parameterId, scalePointId);

  1239.         }

  1240.         else

  1241.             carla_stderr2("carla_get_parameter_scalepoint_info(%i, %i, %i) - parameterId out of bounds", pluginId, parameterId, scalePointId);

  1242. 

  1243.         return &retInfo;

  1244.     }

  1245. 

  1246.     carla_stderr2("carla_get_parameter_scalepoint_info(%i, %i, %i) - could not find plugin", pluginId, parameterId, scalePointId);

  1247.     return &retInfo;

  1248. }

  1249. 

  1250. // --------------------------------------------------------------------------------------------------------------------

  1251. 

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

  1253. {

  1254.     static ParameterData retParamData;

  1255. 

  1256.     // reset

  1257.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1258.     retParamData.hints       = 0x0;

  1259.     retParamData.index       = CB::PARAMETER_NULL;

  1260.     retParamData.rindex      = -1;

  1261.     retParamData.midiCC      = -1;

  1262.     retParamData.midiChannel = 0;

  1263. 

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

  1265. 

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

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

  1268. 

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

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

  1271. 

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

  1273.     retParamData.type        = pluginParamData.type;

  1274.     retParamData.hints       = pluginParamData.hints;

  1275.     retParamData.index       = pluginParamData.index;

  1276.     retParamData.rindex      = pluginParamData.rindex;

  1277.     retParamData.midiCC      = pluginParamData.midiCC;

  1278.     retParamData.midiChannel = pluginParamData.midiChannel;

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

  1280. }

  1281. 

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

  1283. {

  1284.     static ParameterRanges retParamRanges;

  1285. 

  1286.     // reset

  1287.     retParamRanges.def       = 0.0f;

  1288.     retParamRanges.min       = 0.0f;

  1289.     retParamRanges.max       = 1.0f;

  1290.     retParamRanges.step      = 0.01f;

  1291.     retParamRanges.stepSmall = 0.0001f;

  1292.     retParamRanges.stepLarge = 0.1f;

  1293. 

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

  1295. 

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

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

  1298. 

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

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

  1301. 

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

  1303.     retParamRanges.def       = pluginParamRanges.def;

  1304.     retParamRanges.min       = pluginParamRanges.min;

  1305.     retParamRanges.max       = pluginParamRanges.max;

  1306.     retParamRanges.step      = pluginParamRanges.step;

  1307.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1308.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1309.     return &pluginParamRanges;

  1310. }

  1311. 

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

  1313. {

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

  1315. 

  1316.     // reset

  1317.     retMidiProgData.bank    = 0;

  1318.     retMidiProgData.program = 0;

  1319. 

  1320.     if (retMidiProgData.name != nullptr)

  1321.     {

  1322.         delete[] retMidiProgData.name;

  1323.         retMidiProgData.name = gNullCharPtr;

  1324.     }

  1325. 

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

  1327. 

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

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

  1330. 

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

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

  1333. 

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

  1335.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1336.     retMidiProgData.program = pluginMidiProgData.program;

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

  1338.     checkStringPtr(retMidiProgData.name);

  1339.     return &retMidiProgData;

  1340. }

  1341. 

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

  1343. {

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

  1345. 

  1346.     // reset

  1347.     if (retCustomData.type != gNullCharPtr)

  1348.     {

  1349.         delete[] retCustomData.type;

  1350.         retCustomData.type = gNullCharPtr;

  1351.     }

  1352. 

  1353.     if (retCustomData.key != gNullCharPtr)

  1354.     {

  1355.         delete[] retCustomData.key;

  1356.         retCustomData.key = gNullCharPtr;

  1357.     }

  1358. 

  1359.     if (retCustomData.value != gNullCharPtr)

  1360.     {

  1361.         delete[] retCustomData.value;

  1362.         retCustomData.value = gNullCharPtr;

  1363.     }

  1364. 

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

  1366. 

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

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

  1369. 

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

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

  1372. 

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

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

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

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

  1377.     checkStringPtr(retCustomData.type);

  1378.     checkStringPtr(retCustomData.key);

  1379.     checkStringPtr(retCustomData.value);

  1380.     return &retCustomData;

  1381. }

  1382. 

  1383. const char* carla_get_chunk_data(uint pluginId)

  1384. {

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

  1386. 

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

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

  1389. 

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

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

  1392. 

  1393.     void* data = nullptr;

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

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

  1396. 

  1397.     static CarlaString chunkData;

  1398. 

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

  1400.     return chunkData.buffer();

  1401. }

  1402. 

  1403. // --------------------------------------------------------------------------------------------------------------------

  1404. 

  1405. uint32_t carla_get_parameter_count(uint pluginId)

  1406. {

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

  1408. 

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

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

  1411. 

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

  1413.     return plugin->getParameterCount();

  1414. }

  1415. 

  1416. uint32_t carla_get_program_count(uint pluginId)

  1417. {

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

  1419. 

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

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

  1422. 

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

  1424.     return plugin->getProgramCount();

  1425. }

  1426. 

  1427. uint32_t carla_get_midi_program_count(uint pluginId)

  1428. {

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

  1430. 

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

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

  1433. 

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

  1435.     return plugin->getMidiProgramCount();

  1436. }

  1437. 

  1438. uint32_t carla_get_custom_data_count(uint pluginId)

  1439. {

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

  1441. 

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

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

  1444. 

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

  1446.     return plugin->getCustomDataCount();

  1447. }

  1448. 

  1449. // --------------------------------------------------------------------------------------------------------------------

  1450. 

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

  1452. {

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

  1454. 

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

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

  1457. 

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

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

  1460. 

  1461.     static char textBuf[STR_MAX+1];

  1462.     carla_zeroChars(textBuf, STR_MAX+1);

  1463. 

  1464.     plugin->getParameterText(parameterId, textBuf);

  1465.     return textBuf;

  1466. }

  1467. 

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

  1469. {

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

  1471. 

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

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

  1474. 

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

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

  1477. 

  1478.     static char programName[STR_MAX+1];

  1479.     carla_zeroChars(programName, STR_MAX+1);

  1480. 

  1481.     plugin->getProgramName(programId, programName);

  1482.     return programName;

  1483. }

  1484. 

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

  1486. {

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

  1488. 

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

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

  1491. 

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

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

  1494. 

  1495.     static char midiProgramName[STR_MAX+1];

  1496.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1497. 

  1498.     plugin->getMidiProgramName(midiProgramId, midiProgramName);

  1499.     return midiProgramName;

  1500. }

  1501. 

  1502. const char* carla_get_real_plugin_name(uint pluginId)

  1503. {

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

  1505. 

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

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

  1508. 

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

  1510.     static char realPluginName[STR_MAX+1];

  1511.     carla_zeroChars(realPluginName, STR_MAX+1);

  1512. 

  1513.     plugin->getRealName(realPluginName);

  1514.     return realPluginName;

  1515. }

  1516. 

  1517. // --------------------------------------------------------------------------------------------------------------------

  1518. 

  1519. int32_t carla_get_current_program_index(uint pluginId)

  1520. {

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

  1522. 

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

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

  1525. 

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

  1527.     return plugin->getCurrentProgram();

  1528. }

  1529. 

  1530. int32_t carla_get_current_midi_program_index(uint pluginId)

  1531. {

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

  1533. 

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

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

  1536. 

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

  1538.     return plugin->getCurrentMidiProgram();

  1539. }

  1540. 

  1541. // --------------------------------------------------------------------------------------------------------------------

  1542. 

  1543. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1544. {

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

  1546. 

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

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

  1549. 

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

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

  1552. 

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

  1554. }

  1555. 

  1556. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1557. {

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

  1559. 

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

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

  1562. 

  1563.     carla_debug("carla_get_current_parameter_value(%i, %i)", pluginId, parameterId);

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

  1565. 

  1566.     return plugin->getParameterValue(parameterId);

  1567. }

  1568. 

  1569. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1570. {

  1571. #ifdef BUILD_BRIDGE

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

  1573. #else

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

  1575. #endif

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

  1577. 

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

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

  1580. 

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

  1582.     return plugin->getInternalParameterValue(parameterId);

  1583. }

  1584. 

  1585. // --------------------------------------------------------------------------------------------------------------------

  1586. 

  1587. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1588. {

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

  1590. 

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

  1592. }

  1593. 

  1594. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1595. {

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

  1597. 

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

  1599. }

  1600. 

  1601. // --------------------------------------------------------------------------------------------------------------------

  1602. 

  1603. CARLA_BACKEND_START_NAMESPACE

  1604. 

  1605. // defined in CarlaPluginLV2.cpp

  1606. void* carla_render_inline_display_lv2(CarlaPlugin* plugin, int width, int height);

  1607. 

  1608. CARLA_BACKEND_END_NAMESPACE

  1609. 

  1610. CarlaInlineDisplayImageSurface* carla_render_inline_display(uint pluginId, int width, int height)

  1611. {

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

  1613. 

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

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

  1616. 

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

  1618.     CARLA_SAFE_ASSERT_RETURN(plugin->getType() == CB::PLUGIN_LV2, nullptr);

  1619. 

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

  1621. }

  1622. 

  1623. // --------------------------------------------------------------------------------------------------------------------

  1624. 

  1625. void carla_set_active(uint pluginId, bool onOff)

  1626. {

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

  1628. 

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

  1630.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1631. 

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

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

  1634. }

  1635. 

  1636. #ifndef BUILD_BRIDGE

  1637. void carla_set_drywet(uint pluginId, float value)

  1638. {

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

  1640. 

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

  1642.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1643. 

  1644.     carla_debug("carla_set_drywet(%i, %f)", pluginId, value);

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

  1646. }

  1647. 

  1648. void carla_set_volume(uint pluginId, float value)

  1649. {

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

  1651. 

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

  1653.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1654. 

  1655.     carla_debug("carla_set_volume(%i, %f)", pluginId, value);

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

  1657. }

  1658. 

  1659. void carla_set_balance_left(uint pluginId, float value)

  1660. {

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

  1662. 

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

  1664.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1665. 

  1666.     carla_debug("carla_set_balance_left(%i, %f)", pluginId, value);

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

  1668. }

  1669. 

  1670. void carla_set_balance_right(uint pluginId, float value)

  1671. {

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

  1673. 

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

  1675.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1676. 

  1677.     carla_debug("carla_set_balance_right(%i, %f)", pluginId, value);

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

  1679. }

  1680. 

  1681. void carla_set_panning(uint pluginId, float value)

  1682. {

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

  1684. 

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

  1686.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1687. 

  1688.     carla_debug("carla_set_panning(%i, %f)", pluginId, value);

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

  1690. }

  1691. 

  1692. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1693. {

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

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

  1696. 

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

  1698.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1699. 

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

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

  1702. }

  1703. 

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

  1705. {

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

  1707. 

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

  1709.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1710. 

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

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

  1713. }

  1714. #endif

  1715. 

  1716. // --------------------------------------------------------------------------------------------------------------------

  1717. 

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

  1719. {

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

  1721. 

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

  1723.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1724. 

  1725.     carla_debug("carla_set_parameter_value(%i, %i, %f)", pluginId, parameterId, value);

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

  1727. 

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

  1729. }

  1730. 

  1731. #ifndef BUILD_BRIDGE

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

  1733. {

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

  1735.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1736. 

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

  1738.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1739. 

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

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

  1742. 

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

  1744. }

  1745. 

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

  1747. {

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

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

  1750. 

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

  1752.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1753. 

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

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

  1756. 

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

  1758. }

  1759. #endif

  1760. 

  1761. // --------------------------------------------------------------------------------------------------------------------

  1762. 

  1763. void carla_set_program(uint pluginId, uint32_t programId)

  1764. {

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

  1766. 

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

  1768.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1769. 

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

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

  1772. 

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

  1774. }

  1775. 

  1776. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1777. {

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

  1779. 

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

  1781.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1782. 

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

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

  1785. 

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

  1787. }

  1788. 

  1789. // --------------------------------------------------------------------------------------------------------------------

  1790. 

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

  1792. {

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

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

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

  1796.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1797. 

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

  1799.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1800. 

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

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

  1803. }

  1804. 

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

  1806. {

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

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

  1809. 

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

  1811.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1812. 

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

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

  1815. 

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

  1817. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  1819. #else

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

  1821. #endif

  1822. }

  1823. 

  1824. // --------------------------------------------------------------------------------------------------------------------

  1825. 

  1826. void carla_prepare_for_save(uint pluginId)

  1827. {

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

  1829. 

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

  1831.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1832. 

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

  1834.     return plugin->prepareForSave();

  1835. }

  1836. 

  1837. void carla_reset_parameters(uint pluginId)

  1838. {

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

  1840. 

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

  1842.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1843. 

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

  1845.     return plugin->resetParameters();

  1846. }

  1847. 

  1848. void carla_randomize_parameters(uint pluginId)

  1849. {

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

  1851. 

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

  1853.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1854. 

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

  1856.     return plugin->randomizeParameters();

  1857. }

  1858. 

  1859. #ifndef BUILD_BRIDGE

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

  1861. {

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

  1863. 

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

  1865.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1866. 

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

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

  1869. }

  1870. #endif

  1871. 

  1872. void carla_show_custom_ui(uint pluginId, bool yesNo)

  1873. {

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

  1875. 

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

  1877.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1878. 

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

  1880.     return plugin->showCustomUI(yesNo);

  1881. }

  1882. 

  1883. // --------------------------------------------------------------------------------------------------------------------

  1884. 

  1885. uint32_t carla_get_buffer_size()

  1886. {

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

  1888. 

  1889.     carla_debug("carla_get_buffer_size()");

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

  1891. }

  1892. 

  1893. double carla_get_sample_rate()

  1894. {

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

  1896. 

  1897.     carla_debug("carla_get_sample_rate()");

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

  1899. }

  1900. 

  1901. // --------------------------------------------------------------------------------------------------------------------

  1902. 

  1903. const char* carla_get_last_error()

  1904. {

  1905.     carla_debug("carla_get_last_error()");

  1906. 

  1907.     if (gStandalone.engine != nullptr)

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

  1909. 

  1910.     return gStandalone.lastError;

  1911. }

  1912. 

  1913. const char* carla_get_host_osc_url_tcp()

  1914. {

  1915.     carla_debug("carla_get_host_osc_url_tcp()");

  1916. 

  1917. #ifdef HAVE_LIBLO

  1918.     if (gStandalone.engine == nullptr)

  1919.     {

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

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

  1922.         return gNullCharPtr;

  1923.     }

  1924. 

  1925.     return gStandalone.engine->getOscServerPathTCP();

  1926. #else

  1927.     return gNullCharPtr;

  1928. #endif

  1929. }

  1930. 

  1931. const char* carla_get_host_osc_url_udp()

  1932. {

  1933.     carla_debug("carla_get_host_osc_url_udp()");

  1934. 

  1935. #ifdef HAVE_LIBLO

  1936.     if (gStandalone.engine == nullptr)

  1937.     {

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

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

  1940.         return gNullCharPtr;

  1941.     }

  1942. 

  1943.     return gStandalone.engine->getOscServerPathUDP();

  1944. #else

  1945.     return gNullCharPtr;

  1946. #endif

  1947. }

  1948. 

  1949. // --------------------------------------------------------------------------------------------------------------------

  1950. 

  1951. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  1952. #include "CarlaPluginUI.cpp"

  1953. #include "CarlaDssiUtils.cpp"

  1954. #include "CarlaPatchbayUtils.cpp"

  1955. #include "CarlaPipeUtils.cpp"

  1956. #include "CarlaStateUtils.cpp"

  1957. 

  1958. // --------------------------------------------------------------------------------------------------------------------