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

2083 lines
73KB
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. 

  30. #ifdef CARLA_OS_UNIX

  31. # include "CarlaLibUtils.hpp"

  32. #endif

  33. 

  34. #ifdef BUILD_BRIDGE

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

  36. #else

  37. # include "CarlaLogThread.hpp"

  38. #endif

  39. 

  40. #ifdef USING_JUCE

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

  42. #  pragma GCC diagnostic push

  43. #  pragma GCC diagnostic ignored "-Wconversion"

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

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

  46. #  pragma GCC diagnostic ignored "-Wundef"

  47. # endif

  48. 

  49. # include "AppConfig.h"

  50. # include "juce_events/juce_events.h"

  51. 

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

  53. #  pragma GCC diagnostic pop

  54. # endif

  55. #endif

  56. 

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

  58.     if (! (cond)) {                                              \

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

  60.         gStandalone.lastError = msg;                             \

  61.         return ret;                                              \

  62.     }

  63. 

  64. namespace CB = CarlaBackend;

  65. using CB::EngineOptions;

  66. 

  67. // --------------------------------------------------------------------------------------------------------------------

  68. // Single, standalone engine

  69. 

  70. struct CarlaBackendStandalone {

  71.     CarlaEngine*       engine;

  72.     EngineCallbackFunc engineCallback;

  73.     void*              engineCallbackPtr;

  74. #ifndef BUILD_BRIDGE

  75.     EngineOptions      engineOptions;

  76.     CarlaLogThread     logThread;

  77.     bool               logThreadEnabled;

  78. #endif

  79. 

  80.     FileCallbackFunc fileCallback;

  81.     void*            fileCallbackPtr;

  82. 

  83.     CarlaString lastError;

  84. 

  85.     CarlaBackendStandalone() noexcept

  86.         : engine(nullptr),

  87.           engineCallback(nullptr),

  88.           engineCallbackPtr(nullptr),

  89. #ifndef BUILD_BRIDGE

  90.           engineOptions(),

  91.           logThread(),

  92.           logThreadEnabled(false),

  93. #endif

  94.           fileCallback(nullptr),

  95.           fileCallbackPtr(nullptr),

  96.           lastError() {}

  97. 

  98.     ~CarlaBackendStandalone() noexcept

  99.     {

  100.         CARLA_SAFE_ASSERT(engine == nullptr);

  101.     }

  102. 

  103.     CARLA_PREVENT_HEAP_ALLOCATION

  104.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  105. };

  106. 

  107. CarlaBackendStandalone gStandalone;

  108. 

  109. #ifdef CARLA_OS_UNIX

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

  111. // Thread-safe fftw

  112. 

  113. typedef void (*void_func)(void);

  114. 

  115. class ThreadSafeFFTW

  116. {

  117. public:

  118.     struct Deinitializer {

  119.         Deinitializer(ThreadSafeFFTW& s)

  120.             : tsfftw(s) {}

  121. 

  122.         ~Deinitializer()

  123.         {

  124.             tsfftw.deinit();

  125.         }

  126. 

  127.         ThreadSafeFFTW& tsfftw;

  128.     };

  129. 

  130.     ThreadSafeFFTW()

  131.         : libfftw3(nullptr),

  132.           libfftw3f(nullptr),

  133.           libfftw3l(nullptr),

  134.           libfftw3q(nullptr) {}

  135. 

  136.     ~ThreadSafeFFTW()

  137.     {

  138.         CARLA_SAFE_ASSERT(libfftw3 == nullptr);

  139.     }

  140. 

  141.     void init()

  142.     {

  143.         if ((libfftw3 = lib_open("libfftw3_threads.so.3")) != nullptr)

  144.             if (const void_func func = lib_symbol<void_func>(libfftw3, "fftw_make_planner_thread_safe"))

  145.                 func();

  146. 

  147.         if ((libfftw3f = lib_open("libfftw3f_threads.so.3")) != nullptr)

  148.             if (const void_func func = lib_symbol<void_func>(libfftw3f, "fftwf_make_planner_thread_safe"))

  149.                 func();

  150. 

  151.         if ((libfftw3l = lib_open("libfftw3l_threads.so.3")) != nullptr)

  152.             if (const void_func func = lib_symbol<void_func>(libfftw3l, "fftwl_make_planner_thread_safe"))

  153.                 func();

  154. 

  155.         if ((libfftw3q = lib_open("libfftw3q_threads.so.3")) != nullptr)

  156.             if (const void_func func = lib_symbol<void_func>(libfftw3q, "fftwq_make_planner_thread_safe"))

  157.                 func();

  158.     }

  159. 

  160.     void deinit()

  161.     {

  162.         if (libfftw3 != nullptr)

  163.         {

  164.             lib_close(libfftw3);

  165.             libfftw3 = nullptr;

  166.         }

  167. 

  168.         if (libfftw3f != nullptr)

  169.         {

  170.             lib_close(libfftw3f);

  171.             libfftw3f = nullptr;

  172.         }

  173. 

  174.         if (libfftw3l != nullptr)

  175.         {

  176.             lib_close(libfftw3l);

  177.             libfftw3l = nullptr;

  178.         }

  179. 

  180.         if (libfftw3q != nullptr)

  181.         {

  182.             lib_close(libfftw3q);

  183.             libfftw3q = nullptr;

  184.         }

  185.     }

  186. 

  187. private:

  188.     lib_t libfftw3;

  189.     lib_t libfftw3f;

  190.     lib_t libfftw3l;

  191.     lib_t libfftw3q;

  192. 

  193.     CARLA_DECLARE_NON_COPY_CLASS(ThreadSafeFFTW)

  194. };

  195. 

  196. static ThreadSafeFFTW sThreadSafeFFTW;

  197. #endif

  198. 

  199. // --------------------------------------------------------------------------------------------------------------------

  200. // API

  201. 

  202. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  203. #include "CarlaHostCommon.cpp"

  204. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  205. 

  206. // --------------------------------------------------------------------------------------------------------------------

  207. 

  208. uint carla_get_engine_driver_count()

  209. {

  210.     carla_debug("carla_get_engine_driver_count()");

  211. 

  212.     return CarlaEngine::getDriverCount();

  213. }

  214. 

  215. const char* carla_get_engine_driver_name(uint index)

  216. {

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

  218. 

  219.     return CarlaEngine::getDriverName(index);

  220. }

  221. 

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

  223. {

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

  225. 

  226.     return CarlaEngine::getDriverDeviceNames(index);

  227. }

  228. 

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

  230. {

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

  232. 

  233.     static EngineDriverDeviceInfo retDevInfo;

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

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

  236. 

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

  238. 

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

  240.     {

  241.         retDevInfo.hints       =  devInfo->hints;

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

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

  244.     }

  245.     else

  246.     {

  247.         retDevInfo.hints       = 0x0;

  248.         retDevInfo.bufferSizes = nullBufferSizes;

  249.         retDevInfo.sampleRates = nullSampleRates;

  250.     }

  251. 

  252.     return &retDevInfo;

  253. }

  254. 

  255. // --------------------------------------------------------------------------------------------------------------------

  256. 

  257. CarlaEngine* carla_get_engine()

  258. {

  259.     carla_debug("carla_get_engine()");

  260. 

  261.     return gStandalone.engine;

  262. }

  263. 

  264. // --------------------------------------------------------------------------------------------------------------------

  265. 

  266. static void carla_engine_init_common(CarlaEngine* const engine)

  267. {

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

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

  270. 

  271. #ifdef BUILD_BRIDGE

  272.     using water::File;

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

  274. 

  275.     /*

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

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

  278. 

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

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

  281. 

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

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

  284.     */

  285. 

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

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

  288. 

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

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

  291. 

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

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

  294. 

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

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

  297. 

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

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

  300. 

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

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

  303. 

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

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

  306. 

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

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

  309. 

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

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

  312. 

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

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

  315. 

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

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

  318.     else

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

  320. 

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

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

  323.     else

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

  325. 

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

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

  328. 

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

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

  331. #else

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

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

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

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

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

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

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

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

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

  341. 

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

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

  344. 

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

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

  347. 

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

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

  350. 

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

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

  353. 

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

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

  356. 

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

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

  359. 

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

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

  362. 

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

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

  365. 

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

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

  368. 

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

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

  371. 

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

  373. 

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

  375.     {

  376.         char strBuf[STR_MAX+1];

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

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

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

  380.     }

  381.     else

  382.     {

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

  384.     }

  385. 

  386. # ifndef CARLA_OS_WIN

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

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

  389. 

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

  391. 

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

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

  394. 

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

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

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

  398. # endif

  399. #endif

  400. }

  401. 

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

  403. {

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

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

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

  407. 

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

  409. 

  410. #ifdef CARLA_OS_WIN

  411.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  412. #endif

  413. 

  414.     ScopedPointer<CarlaEngine> engine(CarlaEngine::newDriverByName(driverName));

  415. 

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

  417. 

  418. #ifdef BUILD_BRIDGE

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

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

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

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

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

  424. #else

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

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

  427. #endif

  428. 

  429. #ifdef USING_JUCE

  430.     juce::initialiseJuce_GUI();

  431. #endif

  432. 

  433.     carla_engine_init_common(engine);

  434. 

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

  436.     {

  437. #ifndef BUILD_BRIDGE

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

  439.             gStandalone.logThread.init();

  440. #endif

  441. #ifdef CARLA_OS_UNIX

  442.         sThreadSafeFFTW.init();

  443. #endif

  444.         gStandalone.lastError = "No error";

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

  446.         return true;

  447.     }

  448.     else

  449.     {

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

  451. #ifdef USING_JUCE

  452.         juce::shutdownJuce_GUI();

  453. #endif

  454.         return false;

  455.     }

  456. }

  457. 

  458. #ifdef BUILD_BRIDGE

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

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

  461. {

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

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

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

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

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

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

  468. 

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

  470. 

  471.     ScopedPointer<CarlaEngine> engine(CarlaEngine::newBridge(audioBaseName,

  472.                                                              rtClientBaseName,

  473.                                                              nonRtClientBaseName,

  474.                                                              nonRtServerBaseName));

  475. 

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

  477. 

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

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

  480. 

  481.     carla_engine_init_common(engine);

  482. 

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

  484.     {

  485.         gStandalone.lastError = "No error";

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

  487.         return true;

  488.     }

  489.     else

  490.     {

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

  492.         return false;

  493.     }

  494. }

  495. #endif

  496. 

  497. bool carla_engine_close()

  498. {

  499.     carla_debug("carla_engine_close()");

  500. 

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

  502. 

  503. #ifdef CARLA_OS_UNIX

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

  505. #endif

  506. 

  507.     ScopedPointer<CarlaEngine> engine(gStandalone.engine);

  508.     gStandalone.engine = nullptr;

  509. 

  510.     engine->setAboutToClose();

  511.     engine->removeAllPlugins();

  512. 

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

  514. 

  515.     if (! closed)

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

  517. 

  518. #ifndef BUILD_BRIDGE

  519.     gStandalone.logThread.stop();

  520. # ifdef USING_JUCE

  521.     juce::shutdownJuce_GUI();

  522. # endif

  523. #endif

  524. 

  525.     return closed;

  526. }

  527. 

  528. void carla_engine_idle()

  529. {

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

  531. 

  532.     gStandalone.engine->idle();

  533. 

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

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

  536.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  537. 

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

  539. #endif

  540. }

  541. 

  542. bool carla_is_engine_running()

  543. {

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

  545. }

  546. 

  547. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info()

  548. {

  549.     static CarlaRuntimeEngineInfo retInfo;

  550. 

  551.     // reset

  552.     retInfo.load = 0.0f;

  553.     retInfo.xruns = 0;

  554. 

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

  556. 

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

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

  559. 

  560.     return &retInfo;

  561. }

  562. 

  563. void carla_clear_engine_xruns()

  564. {

  565.     if (gStandalone.engine != nullptr)

  566.         gStandalone.engine->clearXruns();

  567. }

  568. 

  569. void carla_cancel_engine_action()

  570. {

  571.     if (gStandalone.engine != nullptr)

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

  573. }

  574. 

  575. bool carla_set_engine_about_to_close()

  576. {

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

  578.     carla_debug("carla_set_engine_about_to_close()");

  579. 

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

  581. }

  582. 

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

  584. {

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

  586. 

  587.     gStandalone.engineCallback    = func;

  588.     gStandalone.engineCallbackPtr = ptr;

  589. 

  590. #ifndef BUILD_BRIDGE

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

  592. #endif

  593. 

  594.     if (gStandalone.engine != nullptr)

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

  596. }

  597. 

  598. #ifndef BUILD_BRIDGE

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

  600. {

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

  602. 

  603.     switch (option)

  604.     {

  605.     case CB::ENGINE_OPTION_DEBUG:

  606.         break;

  607. 

  608.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  611.         break;

  612. 

  613.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  615. 

  616.         if (value != CB::ENGINE_TRANSPORT_MODE_JACK)

  617.         {

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

  619.             if (gStandalone.engineCallback != nullptr)

  620.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,

  621.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  622.                                            0,

  623.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  624.                                            0, 0, 0.0f,

  625.                                            gStandalone.engineOptions.transportExtra);

  626.             CARLA_SAFE_ASSERT_RETURN(gStandalone.engineOptions.processMode != CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS,);

  627.         }

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

  629. 

  630.         delete[] gStandalone.engineOptions.transportExtra;

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

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

  633.         else

  634.             gStandalone.engineOptions.transportExtra = nullptr;

  635.         break;

  636. 

  637.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  640.         break;

  641. 

  642.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  645.         break;

  646. 

  647.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  650.         break;

  651. 

  652.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  655.         break;

  656. 

  657.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  658.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  660.         break;

  661. 

  662.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  663.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  665.         break;

  666. 

  667.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  668.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  670.         break;

  671. 

  672.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  673.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  675.         break;

  676. 

  677.     case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  680.         break;

  681. 

  682.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  683.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  684. 

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

  686.             delete[] gStandalone.engineOptions.audioDevice;

  687. 

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

  689.         break;

  690. 

  691.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  694.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  695. 

  696.         switch (value)

  697.         {

  698.         case CB::PLUGIN_LADSPA:

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

  700.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  702.             break;

  703.         case CB::PLUGIN_DSSI:

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

  705.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  707.             break;

  708.         case CB::PLUGIN_LV2:

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

  710.                 delete[] gStandalone.engineOptions.pathLV2;

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

  712.             break;

  713.         case CB::PLUGIN_VST2:

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

  715.                 delete[] gStandalone.engineOptions.pathVST2;

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

  717.             break;

  718.         case CB::PLUGIN_VST3:

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

  720.                 delete[] gStandalone.engineOptions.pathVST3;

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

  722.             break;

  723.         case CB::PLUGIN_SF2:

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

  725.                 delete[] gStandalone.engineOptions.pathSF2;

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

  727.             break;

  728.         case CB::PLUGIN_SFZ:

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

  730.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  732.             break;

  733.         }

  734.         break;

  735. 

  736.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  738. 

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

  740.             delete[] gStandalone.engineOptions.binaryDir;

  741. 

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

  743.         break;

  744. 

  745.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  747. 

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

  749.             delete[] gStandalone.engineOptions.resourceDir;

  750. 

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

  752.         break;

  753. 

  754.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  757.         break;

  758. 

  759.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  762.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  764.     }   break;

  765. 

  766. #ifndef CARLA_OS_WIN

  767.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  769. 

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

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

  772. 

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

  774.         break;

  775. 

  776.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  779.         break;

  780. 

  781.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  783. 

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

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

  786. 

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

  788.         break;

  789. 

  790.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  793.         break;

  794. 

  795.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  798.         break;

  799. 

  800.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  803.         break;

  804. #endif

  805. 

  806.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  808.         break;

  809.     }

  810. 

  811.     if (gStandalone.engine != nullptr)

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

  813. }

  814. #endif

  815. 

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

  817. {

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

  819. 

  820.     gStandalone.fileCallback    = func;

  821.     gStandalone.fileCallbackPtr = ptr;

  822. 

  823.     if (gStandalone.engine != nullptr)

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

  825. }

  826. 

  827. // --------------------------------------------------------------------------------------------------------------------

  828. 

  829. bool carla_load_file(const char* filename)

  830. {

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

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

  833. 

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

  835. 

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

  837. }

  838. 

  839. bool carla_load_project(const char* filename)

  840. {

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

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

  843. 

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

  845. 

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

  847. }

  848. 

  849. bool carla_save_project(const char* filename)

  850. {

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

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

  853. 

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

  855. 

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

  857. }

  858. 

  859. #ifndef BUILD_BRIDGE

  860. void carla_clear_project_filename()

  861. {

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

  863. 

  864.     carla_debug("carla_clear_project_filename()");

  865. 

  866.     gStandalone.engine->clearCurrentProjectFilename();

  867. }

  868. 

  869. // --------------------------------------------------------------------------------------------------------------------

  870. 

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

  872. {

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

  874. 

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

  876. 

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

  878. }

  879. 

  880. bool carla_patchbay_disconnect(uint connectionId)

  881. {

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

  883. 

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

  885. 

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

  887. }

  888. 

  889. bool carla_patchbay_refresh(bool external)

  890. {

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

  892. 

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

  894. 

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

  896. }

  897. 

  898. // --------------------------------------------------------------------------------------------------------------------

  899. 

  900. void carla_transport_play()

  901. {

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

  903. 

  904.     carla_debug("carla_transport_play()");

  905. 

  906.     gStandalone.engine->transportPlay();

  907. }

  908. 

  909. void carla_transport_pause()

  910. {

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

  912. 

  913.     carla_debug("carla_transport_pause()");

  914. 

  915.     gStandalone.engine->transportPause();

  916. }

  917. 

  918. void carla_transport_bpm(double bpm)

  919. {

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

  921. 

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

  923. 

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

  925. }

  926. 

  927. void carla_transport_relocate(uint64_t frame)

  928. {

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

  930. 

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

  932. 

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

  934. }

  935. 

  936. uint64_t carla_get_current_transport_frame()

  937. {

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

  939. 

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

  941. }

  942. 

  943. const CarlaTransportInfo* carla_get_transport_info()

  944. {

  945.     static CarlaTransportInfo retTransInfo;

  946.     retTransInfo.clear();

  947. 

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

  949. 

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

  951. 

  952.     retTransInfo.playing = timeInfo.playing;

  953.     retTransInfo.frame   = timeInfo.frame;

  954. 

  955.     if (timeInfo.bbt.valid)

  956.     {

  957.         retTransInfo.bar  = timeInfo.bbt.bar;

  958.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  961.     }

  962. 

  963.     return &retTransInfo;

  964. }

  965. #endif

  966. 

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

  968. 

  969. uint32_t carla_get_current_plugin_count()

  970. {

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

  972. 

  973.     carla_debug("carla_get_current_plugin_count()");

  974. 

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

  976. }

  977. 

  978. uint32_t carla_get_max_plugin_number()

  979. {

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

  981. 

  982.     carla_debug("carla_get_max_plugin_number()");

  983. 

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

  985. }

  986. 

  987. // --------------------------------------------------------------------------------------------------------------------

  988. 

  989. bool carla_add_plugin(BinaryType btype, PluginType ptype,

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

  991.                       const void* extraPtr, uint options)

  992. {

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

  994. 

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

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

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

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

  999. 

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

  1001. }

  1002. 

  1003. bool carla_remove_plugin(uint pluginId)

  1004. {

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

  1006. 

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

  1008. 

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

  1010. }

  1011. 

  1012. bool carla_remove_all_plugins()

  1013. {

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

  1015. 

  1016.     carla_debug("carla_remove_all_plugins()");

  1017. 

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

  1019. }

  1020. 

  1021. #ifndef BUILD_BRIDGE

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

  1023. {

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

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

  1026. 

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

  1028. 

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

  1030. }

  1031. 

  1032. bool carla_clone_plugin(uint pluginId)

  1033. {

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

  1035. 

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

  1037. 

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

  1039. }

  1040. 

  1041. bool carla_replace_plugin(uint pluginId)

  1042. {

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

  1044. 

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

  1046. 

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

  1048. }

  1049. 

  1050. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1051. {

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

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

  1054. 

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

  1056. 

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

  1058. }

  1059. #endif

  1060. 

  1061. // --------------------------------------------------------------------------------------------------------------------

  1062. 

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

  1064. {

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

  1066.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr

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

  1068. 

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

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

  1071. 

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

  1073. 

  1074.     return plugin->loadStateFromFile(filename);

  1075. }

  1076. 

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

  1078. {

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

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

  1081. 

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

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

  1084. 

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

  1086. 

  1087.     return plugin->saveStateToFile(filename);

  1088. }

  1089. 

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

  1091. {

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

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

  1094. 

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

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

  1097. 

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

  1099. 

  1100.     return plugin->exportAsLV2(lv2path);

  1101. }

  1102. 

  1103. // --------------------------------------------------------------------------------------------------------------------

  1104. 

  1105. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1106. {

  1107.     static CarlaPluginInfo retInfo;

  1108. 

  1109.     // reset

  1110.     retInfo.type             = CB::PLUGIN_NONE;

  1111.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1112.     retInfo.hints            = 0x0;

  1113.     retInfo.optionsAvailable = 0x0;

  1114.     retInfo.optionsEnabled   = 0x0;

  1115.     retInfo.filename         = gNullCharPtr;

  1116.     retInfo.name             = gNullCharPtr;

  1117.     retInfo.iconName         = gNullCharPtr;

  1118.     retInfo.uniqueId         = 0;

  1119. 

  1120.     // cleanup

  1121.     if (retInfo.label != gNullCharPtr)

  1122.     {

  1123.         delete[] retInfo.label;

  1124.         retInfo.label = gNullCharPtr;

  1125.     }

  1126. 

  1127.     if (retInfo.maker != gNullCharPtr)

  1128.     {

  1129.         delete[] retInfo.maker;

  1130.         retInfo.maker = gNullCharPtr;

  1131.     }

  1132. 

  1133.     if (retInfo.copyright != gNullCharPtr)

  1134.     {

  1135.         delete[] retInfo.copyright;

  1136.         retInfo.copyright = gNullCharPtr;

  1137.     }

  1138. 

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

  1140. 

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

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

  1143. 

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

  1145. 

  1146.     char strBuf[STR_MAX+1];

  1147. 

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

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

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

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

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

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

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

  1155. 

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

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

  1158. 

  1159.     carla_zeroChars(strBuf, STR_MAX+1);

  1160.     plugin->getLabel(strBuf);

  1161.     retInfo.label = carla_strdup_safe(strBuf);

  1162. 

  1163.     carla_zeroChars(strBuf, STR_MAX+1);

  1164.     plugin->getMaker(strBuf);

  1165.     retInfo.maker = carla_strdup_safe(strBuf);

  1166. 

  1167.     carla_zeroChars(strBuf, STR_MAX+1);

  1168.     plugin->getCopyright(strBuf);

  1169.     retInfo.copyright = carla_strdup_safe(strBuf);

  1170. 

  1171.     checkStringPtr(retInfo.filename);

  1172.     checkStringPtr(retInfo.name);

  1173.     checkStringPtr(retInfo.iconName);

  1174.     checkStringPtr(retInfo.label);

  1175.     checkStringPtr(retInfo.maker);

  1176.     checkStringPtr(retInfo.copyright);

  1177. 

  1178.     return &retInfo;

  1179. }

  1180. 

  1181. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1182. {

  1183.     static CarlaPortCountInfo retInfo;

  1184.     carla_zeroStruct(retInfo);

  1185. 

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

  1187. 

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

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

  1190. 

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

  1192. 

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

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

  1195.     return &retInfo;

  1196. }

  1197. 

  1198. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1199. {

  1200.     static CarlaPortCountInfo retInfo;

  1201.     carla_zeroStruct(retInfo);

  1202. 

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

  1204. 

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

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

  1207. 

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

  1209. 

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

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

  1212.     return &retInfo;

  1213. }

  1214. 

  1215. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1216. {

  1217.     static CarlaPortCountInfo retInfo;

  1218.     carla_zeroStruct(retInfo);

  1219. 

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

  1221. 

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

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

  1224. 

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

  1226. 

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

  1228.     return &retInfo;

  1229. }

  1230. 

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

  1232. {

  1233.     static CarlaParameterInfo retInfo;

  1234. 

  1235.     // reset

  1236.     retInfo.scalePointCount = 0;

  1237. 

  1238.     // cleanup

  1239.     if (retInfo.name != gNullCharPtr)

  1240.     {

  1241.         delete[] retInfo.name;

  1242.         retInfo.name = gNullCharPtr;

  1243.     }

  1244. 

  1245.     if (retInfo.symbol != gNullCharPtr)

  1246.     {

  1247.         delete[] retInfo.symbol;

  1248.         retInfo.symbol = gNullCharPtr;

  1249.     }

  1250. 

  1251.     if (retInfo.unit != gNullCharPtr)

  1252.     {

  1253.         delete[] retInfo.unit;

  1254.         retInfo.unit = gNullCharPtr;

  1255.     }

  1256. 

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

  1258. 

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

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

  1261. 

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

  1263. 

  1264.     char strBuf[STR_MAX+1];

  1265. 

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

  1267. 

  1268.     carla_zeroChars(strBuf, STR_MAX+1);

  1269.     plugin->getParameterName(parameterId, strBuf);

  1270.     retInfo.name = carla_strdup_safe(strBuf);

  1271. 

  1272.     carla_zeroChars(strBuf, STR_MAX+1);

  1273.     plugin->getParameterSymbol(parameterId, strBuf);

  1274.     retInfo.symbol = carla_strdup_safe(strBuf);

  1275. 

  1276.     carla_zeroChars(strBuf, STR_MAX+1);

  1277.     plugin->getParameterUnit(parameterId, strBuf);

  1278.     retInfo.unit = carla_strdup_safe(strBuf);

  1279. 

  1280.     checkStringPtr(retInfo.name);

  1281.     checkStringPtr(retInfo.symbol);

  1282.     checkStringPtr(retInfo.unit);

  1283. 

  1284.     return &retInfo;

  1285. }

  1286. 

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

  1288. {

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

  1290. 

  1291.     static CarlaScalePointInfo retInfo;

  1292. 

  1293.     // reset

  1294.     retInfo.value = 0.0f;

  1295. 

  1296.     // cleanup

  1297.     if (retInfo.label != gNullCharPtr)

  1298.     {

  1299.         delete[] retInfo.label;

  1300.         retInfo.label = gNullCharPtr;

  1301.     }

  1302. 

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

  1304. 

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

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

  1307. 

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

  1309. 

  1310.     char strBuf[STR_MAX+1];

  1311. 

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

  1313. 

  1314.     carla_zeroChars(strBuf, STR_MAX+1);

  1315.     plugin->getParameterScalePointLabel(parameterId, scalePointId, strBuf);

  1316.     retInfo.label = carla_strdup_safe(strBuf);

  1317. 

  1318.     checkStringPtr(retInfo.label);

  1319. 

  1320.     return &retInfo;

  1321. }

  1322. 

  1323. // --------------------------------------------------------------------------------------------------------------------

  1324. 

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

  1326. {

  1327.     static ParameterData retParamData;

  1328. 

  1329.     // reset

  1330.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1331.     retParamData.hints       = 0x0;

  1332.     retParamData.index       = CB::PARAMETER_NULL;

  1333.     retParamData.rindex      = -1;

  1334.     retParamData.midiCC      = -1;

  1335.     retParamData.midiChannel = 0;

  1336. 

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

  1338. 

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

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

  1341. 

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

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

  1344. 

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

  1346.     retParamData.type        = pluginParamData.type;

  1347.     retParamData.hints       = pluginParamData.hints;

  1348.     retParamData.index       = pluginParamData.index;

  1349.     retParamData.rindex      = pluginParamData.rindex;

  1350.     retParamData.midiCC      = pluginParamData.midiCC;

  1351.     retParamData.midiChannel = pluginParamData.midiChannel;

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

  1353. }

  1354. 

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

  1356. {

  1357.     static ParameterRanges retParamRanges;

  1358. 

  1359.     // reset

  1360.     retParamRanges.def       = 0.0f;

  1361.     retParamRanges.min       = 0.0f;

  1362.     retParamRanges.max       = 1.0f;

  1363.     retParamRanges.step      = 0.01f;

  1364.     retParamRanges.stepSmall = 0.0001f;

  1365.     retParamRanges.stepLarge = 0.1f;

  1366. 

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

  1368. 

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

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

  1371. 

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

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

  1374. 

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

  1376.     retParamRanges.def       = pluginParamRanges.def;

  1377.     retParamRanges.min       = pluginParamRanges.min;

  1378.     retParamRanges.max       = pluginParamRanges.max;

  1379.     retParamRanges.step      = pluginParamRanges.step;

  1380.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1381.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1382.     return &pluginParamRanges;

  1383. }

  1384. 

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

  1386. {

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

  1388. 

  1389.     // reset

  1390.     retMidiProgData.bank    = 0;

  1391.     retMidiProgData.program = 0;

  1392. 

  1393.     if (retMidiProgData.name != gNullCharPtr)

  1394.     {

  1395.         delete[] retMidiProgData.name;

  1396.         retMidiProgData.name = gNullCharPtr;

  1397.     }

  1398. 

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

  1400. 

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

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

  1403. 

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

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

  1406. 

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

  1408.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1409.     retMidiProgData.program = pluginMidiProgData.program;

  1410. 

  1411.     if (pluginMidiProgData.name != nullptr)

  1412.     {

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

  1414.         checkStringPtr(retMidiProgData.name);

  1415.     }

  1416.     else

  1417.     {

  1418.         retMidiProgData.name = gNullCharPtr;

  1419.     }

  1420. 

  1421.     return &retMidiProgData;

  1422. }

  1423. 

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

  1425. {

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

  1427. 

  1428.     // reset

  1429.     if (retCustomData.type != gNullCharPtr)

  1430.     {

  1431.         delete[] retCustomData.type;

  1432.         retCustomData.type = gNullCharPtr;

  1433.     }

  1434. 

  1435.     if (retCustomData.key != gNullCharPtr)

  1436.     {

  1437.         delete[] retCustomData.key;

  1438.         retCustomData.key = gNullCharPtr;

  1439.     }

  1440. 

  1441.     if (retCustomData.value != gNullCharPtr)

  1442.     {

  1443.         delete[] retCustomData.value;

  1444.         retCustomData.value = gNullCharPtr;

  1445.     }

  1446. 

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

  1448. 

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

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

  1451. 

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

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

  1454. 

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

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

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

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

  1459.     checkStringPtr(retCustomData.type);

  1460.     checkStringPtr(retCustomData.key);

  1461.     checkStringPtr(retCustomData.value);

  1462.     return &retCustomData;

  1463. }

  1464. 

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

  1466. {

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

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

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

  1470. 

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

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

  1473. 

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

  1475. 

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

  1477. 

  1478.     if (count == 0)

  1479.         return gNullCharPtr;

  1480. 

  1481.     static CarlaString customDataValue;

  1482. 

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

  1484.     {

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

  1486. 

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

  1488.             continue;

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

  1490.             continue;

  1491. 

  1492.         customDataValue = pluginCustomData.value;

  1493.         return customDataValue.buffer();

  1494.     }

  1495. 

  1496.     return gNullCharPtr;

  1497. }

  1498. 

  1499. const char* carla_get_chunk_data(uint pluginId)

  1500. {

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

  1502. 

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

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

  1505. 

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

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

  1508. 

  1509.     void* data = nullptr;

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

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

  1512. 

  1513.     static CarlaString chunkData;

  1514. 

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

  1516.     return chunkData.buffer();

  1517. }

  1518. 

  1519. // --------------------------------------------------------------------------------------------------------------------

  1520. 

  1521. uint32_t carla_get_parameter_count(uint pluginId)

  1522. {

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

  1524. 

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

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

  1527. 

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

  1529.     return plugin->getParameterCount();

  1530. }

  1531. 

  1532. uint32_t carla_get_program_count(uint pluginId)

  1533. {

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

  1535. 

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

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

  1538. 

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

  1540.     return plugin->getProgramCount();

  1541. }

  1542. 

  1543. uint32_t carla_get_midi_program_count(uint pluginId)

  1544. {

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

  1546. 

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

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

  1549. 

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

  1551.     return plugin->getMidiProgramCount();

  1552. }

  1553. 

  1554. uint32_t carla_get_custom_data_count(uint pluginId)

  1555. {

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

  1557. 

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

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

  1560. 

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

  1562.     return plugin->getCustomDataCount();

  1563. }

  1564. 

  1565. // --------------------------------------------------------------------------------------------------------------------

  1566. 

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

  1568. {

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

  1570. 

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

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

  1573. 

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

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

  1576. 

  1577.     static char textBuf[STR_MAX+1];

  1578.     carla_zeroChars(textBuf, STR_MAX+1);

  1579. 

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

  1581.     return textBuf;

  1582. }

  1583. 

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

  1585. {

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

  1587. 

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

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

  1590. 

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

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

  1593. 

  1594.     static char programName[STR_MAX+1];

  1595.     carla_zeroChars(programName, STR_MAX+1);

  1596. 

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

  1598.     return programName;

  1599. }

  1600. 

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

  1602. {

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

  1604. 

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

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

  1607. 

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

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

  1610. 

  1611.     static char midiProgramName[STR_MAX+1];

  1612.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1613. 

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

  1615.     return midiProgramName;

  1616. }

  1617. 

  1618. const char* carla_get_real_plugin_name(uint pluginId)

  1619. {

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

  1621. 

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

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

  1624. 

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

  1626.     static char realPluginName[STR_MAX+1];

  1627.     carla_zeroChars(realPluginName, STR_MAX+1);

  1628. 

  1629.     plugin->getRealName(realPluginName);

  1630.     return realPluginName;

  1631. }

  1632. 

  1633. // --------------------------------------------------------------------------------------------------------------------

  1634. 

  1635. int32_t carla_get_current_program_index(uint pluginId)

  1636. {

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

  1638. 

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

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

  1641. 

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

  1643.     return plugin->getCurrentProgram();

  1644. }

  1645. 

  1646. int32_t carla_get_current_midi_program_index(uint pluginId)

  1647. {

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

  1649. 

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

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

  1652. 

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

  1654.     return plugin->getCurrentMidiProgram();

  1655. }

  1656. 

  1657. // --------------------------------------------------------------------------------------------------------------------

  1658. 

  1659. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1660. {

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

  1662. 

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

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

  1665. 

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

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

  1668. 

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

  1670. }

  1671. 

  1672. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1673. {

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

  1675. 

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

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

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

  1679. 

  1680.     return plugin->getParameterValue(parameterId);

  1681. }

  1682. 

  1683. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1684. {

  1685. #ifdef BUILD_BRIDGE

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

  1687. #else

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

  1689. #endif

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

  1691. 

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

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

  1694. 

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

  1696.     return plugin->getInternalParameterValue(parameterId);

  1697. }

  1698. 

  1699. // --------------------------------------------------------------------------------------------------------------------

  1700. 

  1701. float* carla_get_peak_values(uint pluginId)

  1702. {

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

  1704. 

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

  1706. }

  1707. 

  1708. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1709. {

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

  1711. 

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

  1713. }

  1714. 

  1715. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1716. {

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

  1718. 

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

  1720. }

  1721. 

  1722. // --------------------------------------------------------------------------------------------------------------------

  1723. 

  1724. CARLA_BACKEND_START_NAMESPACE

  1725. 

  1726. // defined in CarlaPluginLV2.cpp

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

  1728. 

  1729. CARLA_BACKEND_END_NAMESPACE

  1730. 

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

  1732. {

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

  1734. 

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

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

  1737. 

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

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

  1740. 

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

  1742. }

  1743. 

  1744. // --------------------------------------------------------------------------------------------------------------------

  1745. 

  1746. void carla_set_active(uint pluginId, bool onOff)

  1747. {

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

  1749. 

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

  1751.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1752. 

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

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

  1755. }

  1756. 

  1757. #ifndef BUILD_BRIDGE

  1758. void carla_set_drywet(uint pluginId, float value)

  1759. {

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

  1761. 

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

  1763.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1764. 

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

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

  1767. }

  1768. 

  1769. void carla_set_volume(uint pluginId, float value)

  1770. {

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

  1772. 

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

  1774.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1775. 

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

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

  1778. }

  1779. 

  1780. void carla_set_balance_left(uint pluginId, float value)

  1781. {

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

  1783. 

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

  1785.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1786. 

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

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

  1789. }

  1790. 

  1791. void carla_set_balance_right(uint pluginId, float value)

  1792. {

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

  1794. 

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

  1796.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1797. 

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

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

  1800. }

  1801. 

  1802. void carla_set_panning(uint pluginId, float value)

  1803. {

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

  1805. 

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

  1807.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1808. 

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

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

  1811. }

  1812. 

  1813. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1814. {

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

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

  1817. 

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

  1819.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1820. 

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

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

  1823. }

  1824. #endif

  1825. 

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

  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_set_option(%i, %i, %s)", pluginId, option, bool2str(yesNo));

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

  1835. }

  1836. 

  1837. // --------------------------------------------------------------------------------------------------------------------

  1838. 

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

  1840. {

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

  1842. 

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

  1844.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1845. 

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

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

  1848. 

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

  1850. }

  1851. 

  1852. #ifndef BUILD_BRIDGE

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

  1854. {

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

  1856.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1857. 

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

  1859.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1860. 

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

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

  1863. 

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

  1865. }

  1866. 

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

  1868. {

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

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

  1871. 

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

  1873.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1874. 

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

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

  1877. 

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

  1879. }

  1880. #endif

  1881. 

  1882. // --------------------------------------------------------------------------------------------------------------------

  1883. 

  1884. void carla_set_program(uint pluginId, uint32_t programId)

  1885. {

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

  1887. 

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

  1889.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1890. 

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

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

  1893. 

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

  1895. }

  1896. 

  1897. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1898. {

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

  1900. 

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

  1902.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1903. 

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

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

  1906. 

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

  1908. }

  1909. 

  1910. // --------------------------------------------------------------------------------------------------------------------

  1911. 

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

  1913. {

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

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

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

  1917.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1918. 

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

  1920.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1921. 

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

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

  1924. }

  1925. 

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

  1927. {

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

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

  1930. 

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

  1932.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1933. 

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

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

  1936. 

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

  1938. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  1940. #else

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

  1942. #endif

  1943. }

  1944. 

  1945. // --------------------------------------------------------------------------------------------------------------------

  1946. 

  1947. void carla_prepare_for_save(uint pluginId)

  1948. {

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

  1950. 

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

  1952.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1953. 

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

  1955.     return plugin->prepareForSave();

  1956. }

  1957. 

  1958. void carla_reset_parameters(uint pluginId)

  1959. {

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

  1961. 

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

  1963.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1964. 

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

  1966.     return plugin->resetParameters();

  1967. }

  1968. 

  1969. void carla_randomize_parameters(uint pluginId)

  1970. {

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

  1972. 

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

  1974.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1975. 

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

  1977.     return plugin->randomizeParameters();

  1978. }

  1979. 

  1980. #ifndef BUILD_BRIDGE

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

  1982. {

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

  1984. 

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

  1986.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1987. 

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

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

  1990. }

  1991. #endif

  1992. 

  1993. void carla_show_custom_ui(uint pluginId, bool yesNo)

  1994. {

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

  1996. 

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

  1998.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1999. 

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

  2001.     return plugin->showCustomUI(yesNo);

  2002. }

  2003. 

  2004. // --------------------------------------------------------------------------------------------------------------------

  2005. 

  2006. uint32_t carla_get_buffer_size()

  2007. {

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

  2009. 

  2010.     carla_debug("carla_get_buffer_size()");

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

  2012. }

  2013. 

  2014. double carla_get_sample_rate()

  2015. {

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

  2017. 

  2018.     carla_debug("carla_get_sample_rate()");

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

  2020. }

  2021. 

  2022. // --------------------------------------------------------------------------------------------------------------------

  2023. 

  2024. const char* carla_get_last_error()

  2025. {

  2026.     carla_debug("carla_get_last_error()");

  2027. 

  2028.     if (gStandalone.engine != nullptr)

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

  2030. 

  2031.     return gStandalone.lastError;

  2032. }

  2033. 

  2034. const char* carla_get_host_osc_url_tcp()

  2035. {

  2036.     carla_debug("carla_get_host_osc_url_tcp()");

  2037. 

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

  2039.     if (gStandalone.engine == nullptr)

  2040.     {

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

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

  2043.         return gNullCharPtr;

  2044.     }

  2045. 

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

  2047. #else

  2048.     return gNullCharPtr;

  2049. #endif

  2050. }

  2051. 

  2052. const char* carla_get_host_osc_url_udp()

  2053. {

  2054.     carla_debug("carla_get_host_osc_url_udp()");

  2055. 

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

  2057.     if (gStandalone.engine == nullptr)

  2058.     {

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

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

  2061.         return gNullCharPtr;

  2062.     }

  2063. 

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

  2065. #else

  2066.     return gNullCharPtr;

  2067. #endif

  2068. }

  2069. 

  2070. // --------------------------------------------------------------------------------------------------------------------

  2071. 

  2072. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2073. #include "CarlaPluginUI.cpp"

  2074. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2075. 

  2076. #include "CarlaDssiUtils.cpp"

  2077. #include "CarlaMacUtils.cpp"

  2078. #include "CarlaPatchbayUtils.cpp"

  2079. #include "CarlaPipeUtils.cpp"

  2080. #include "CarlaStateUtils.cpp"

  2081. 

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