falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
4839 Commits
17 Branches
940MB
Tree: 8a2caa7b9f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8a2caa7b9f'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2129 lines
75KB
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.         : initialized(false),

  132.           libfftw3(nullptr),

  133.           libfftw3f(nullptr),

  134.           libfftw3l(nullptr),

  135.           libfftw3q(nullptr) {}

  136. 

  137.     ~ThreadSafeFFTW()

  138.     {

  139.         CARLA_SAFE_ASSERT(libfftw3 == nullptr);

  140.     }

  141. 

  142.     void init()

  143.     {

  144.         if (initialized)

  145.             return;

  146.         initialized = true;

  147. 

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

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

  150.                 func();

  151. 

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

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

  154.                 func();

  155. 

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

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

  158.                 func();

  159. 

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

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

  162.                 func();

  163.     }

  164. 

  165.     void deinit()

  166.     {

  167.         if (! initialized)

  168.             return;

  169.         initialized = false;

  170. 

  171.         if (libfftw3 != nullptr)

  172.         {

  173.             lib_close(libfftw3);

  174.             libfftw3 = nullptr;

  175.         }

  176. 

  177.         if (libfftw3f != nullptr)

  178.         {

  179.             lib_close(libfftw3f);

  180.             libfftw3f = nullptr;

  181.         }

  182. 

  183.         if (libfftw3l != nullptr)

  184.         {

  185.             lib_close(libfftw3l);

  186.             libfftw3l = nullptr;

  187.         }

  188. 

  189.         if (libfftw3q != nullptr)

  190.         {

  191.             lib_close(libfftw3q);

  192.             libfftw3q = nullptr;

  193.         }

  194.     }

  195. 

  196. private:

  197.     bool initialized;

  198.     lib_t libfftw3;

  199.     lib_t libfftw3f;

  200.     lib_t libfftw3l;

  201.     lib_t libfftw3q;

  202. 

  203.     CARLA_DECLARE_NON_COPY_CLASS(ThreadSafeFFTW)

  204. };

  205. 

  206. static ThreadSafeFFTW sThreadSafeFFTW;

  207. #endif

  208. 

  209. // --------------------------------------------------------------------------------------------------------------------

  210. // API

  211. 

  212. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  213. #include "CarlaHostCommon.cpp"

  214. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  215. 

  216. // --------------------------------------------------------------------------------------------------------------------

  217. 

  218. uint carla_get_engine_driver_count()

  219. {

  220.     carla_debug("carla_get_engine_driver_count()");

  221. 

  222.     return CarlaEngine::getDriverCount();

  223. }

  224. 

  225. const char* carla_get_engine_driver_name(uint index)

  226. {

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

  228. 

  229.     return CarlaEngine::getDriverName(index);

  230. }

  231. 

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

  233. {

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

  235. 

  236.     return CarlaEngine::getDriverDeviceNames(index);

  237. }

  238. 

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

  240. {

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

  242. 

  243.     static EngineDriverDeviceInfo retDevInfo;

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

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

  246. 

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

  248. 

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

  250.     {

  251.         retDevInfo.hints       =  devInfo->hints;

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

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

  254.     }

  255.     else

  256.     {

  257.         retDevInfo.hints       = 0x0;

  258.         retDevInfo.bufferSizes = nullBufferSizes;

  259.         retDevInfo.sampleRates = nullSampleRates;

  260.     }

  261. 

  262.     return &retDevInfo;

  263. }

  264. 

  265. // --------------------------------------------------------------------------------------------------------------------

  266. 

  267. CarlaEngine* carla_get_engine()

  268. {

  269.     carla_debug("carla_get_engine()");

  270. 

  271.     return gStandalone.engine;

  272. }

  273. 

  274. // --------------------------------------------------------------------------------------------------------------------

  275. 

  276. static void carla_engine_init_common(CarlaEngine* const engine)

  277. {

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

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

  280. 

  281. #ifdef BUILD_BRIDGE

  282.     using water::File;

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

  284. 

  285.     /*

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

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

  288. 

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

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

  291. 

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

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

  294.     */

  295. 

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

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

  298. 

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

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

  301. 

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

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

  304. 

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

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

  307. 

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

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

  310. 

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

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

  313. 

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

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

  316. 

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

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

  319. 

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

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

  322. 

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

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

  325. 

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

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

  328.     else

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

  330. 

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

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

  333.     else

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

  335. 

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

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

  338. 

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

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

  341. #else

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

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

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

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

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

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

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

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

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

  351. 

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

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

  354. 

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

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

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

  358. 

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

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

  361. 

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

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

  364. 

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

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

  367. 

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

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

  370. 

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

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

  373. 

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

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

  376. 

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

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

  379. 

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

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

  382. 

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

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

  385. 

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

  387. 

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

  389.     {

  390.         char strBuf[STR_MAX+1];

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

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

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

  394.     }

  395.     else

  396.     {

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

  398.     }

  399. 

  400. # ifndef CARLA_OS_WIN

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

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

  403. 

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

  405. 

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

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

  408. 

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

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

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

  412. # endif

  413. #endif

  414. }

  415. 

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

  417. {

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

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

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

  421. 

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

  423. 

  424. #ifdef CARLA_OS_WIN

  425.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  426. #endif

  427. 

  428. #ifdef USING_JUCE

  429.     juce::initialiseJuce_GUI();

  430. #endif

  431. 

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

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

  434. 

  435.     gStandalone.engine = engine;

  436. 

  437. #ifdef BUILD_BRIDGE

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

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

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

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

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

  443. #else

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

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

  446. #endif

  447. 

  448.     carla_engine_init_common(engine);

  449. 

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

  451.     {

  452. #ifndef BUILD_BRIDGE

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

  454.             gStandalone.logThread.init();

  455. #endif

  456. #ifdef CARLA_OS_UNIX

  457.         sThreadSafeFFTW.init();

  458. #endif

  459.         gStandalone.lastError = "No error";

  460.         return true;

  461.     }

  462.     else

  463.     {

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

  465.         gStandalone.engine = nullptr;

  466.         delete engine;

  467. #ifdef USING_JUCE

  468.         juce::shutdownJuce_GUI();

  469. #endif

  470.         return false;

  471.     }

  472. }

  473. 

  474. #ifdef BUILD_BRIDGE

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

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

  477. {

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

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

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

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

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

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

  484. 

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

  486. 

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

  488.                                                              rtClientBaseName,

  489.                                                              nonRtClientBaseName,

  490.                                                              nonRtServerBaseName));

  491. 

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

  493. 

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

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

  496. 

  497.     carla_engine_init_common(engine);

  498. 

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

  500.     {

  501.         gStandalone.lastError = "No error";

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

  503.         return true;

  504.     }

  505.     else

  506.     {

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

  508.         return false;

  509.     }

  510. }

  511. #endif

  512. 

  513. bool carla_engine_close()

  514. {

  515.     carla_debug("carla_engine_close()");

  516. 

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

  518. 

  519. #ifdef CARLA_OS_UNIX

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

  521. #endif

  522. 

  523.     CarlaEngine* const engine = gStandalone.engine;

  524. 

  525.     engine->setAboutToClose();

  526.     engine->removeAllPlugins();

  527. 

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

  529. 

  530.     if (! closed)

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

  532. 

  533. #ifndef BUILD_BRIDGE

  534.     gStandalone.logThread.stop();

  535. #endif

  536. 

  537.     gStandalone.engine = nullptr;

  538.     delete engine;

  539. 

  540. #ifdef USING_JUCE

  541.     juce::shutdownJuce_GUI();

  542. #endif

  543.     return closed;

  544. }

  545. 

  546. void carla_engine_idle()

  547. {

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

  549. 

  550.     gStandalone.engine->idle();

  551. 

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

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

  554.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  555. 

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

  557. #endif

  558. }

  559. 

  560. bool carla_is_engine_running()

  561. {

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

  563. }

  564. 

  565. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info()

  566. {

  567.     static CarlaRuntimeEngineInfo retInfo;

  568. 

  569.     // reset

  570.     retInfo.load = 0.0f;

  571.     retInfo.xruns = 0;

  572. 

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

  574. 

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

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

  577. 

  578.     return &retInfo;

  579. }

  580. 

  581. void carla_clear_engine_xruns()

  582. {

  583.     if (gStandalone.engine != nullptr)

  584.         gStandalone.engine->clearXruns();

  585. }

  586. 

  587. void carla_cancel_engine_action()

  588. {

  589.     if (gStandalone.engine != nullptr)

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

  591. }

  592. 

  593. bool carla_set_engine_about_to_close()

  594. {

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

  596.     carla_debug("carla_set_engine_about_to_close()");

  597. 

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

  599. }

  600. 

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

  602. {

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

  604. 

  605.     gStandalone.engineCallback    = func;

  606.     gStandalone.engineCallbackPtr = ptr;

  607. 

  608. #ifndef BUILD_BRIDGE

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

  610. #endif

  611. 

  612.     if (gStandalone.engine != nullptr)

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

  614. }

  615. 

  616. #ifndef BUILD_BRIDGE

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

  618. {

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

  620. 

  621.     switch (option)

  622.     {

  623.     case CB::ENGINE_OPTION_DEBUG:

  624.         break;

  625. 

  626.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  629.         break;

  630. 

  631.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  633. 

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

  635.         {

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

  637.             if (gStandalone.engineCallback != nullptr)

  638.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,

  639.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  640.                                            0,

  641.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  642.                                            0, 0, 0.0f,

  643.                                            gStandalone.engineOptions.transportExtra);

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

  645.         }

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

  647. 

  648.         delete[] gStandalone.engineOptions.transportExtra;

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

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

  651.         else

  652.             gStandalone.engineOptions.transportExtra = nullptr;

  653.         break;

  654. 

  655.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  658.         break;

  659. 

  660.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  663.         break;

  664. 

  665.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  668.         break;

  669. 

  670.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  673.         break;

  674. 

  675.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  676.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  678.         break;

  679. 

  680.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  681.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  683.         break;

  684. 

  685.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  686.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  688.         break;

  689. 

  690.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  691.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  693.         break;

  694. 

  695.     case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  698.         break;

  699. 

  700.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  701.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  702. 

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

  704.             delete[] gStandalone.engineOptions.audioDevice;

  705. 

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

  707.         break;

  708. 

  709.     case CB::ENGINE_OPTION_OSC_ENABLED:

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

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

  712.         break;

  713. 

  714.     case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  716.         gStandalone.engineOptions.oscPortTCP = value;

  717.         break;

  718. 

  719.     case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  721.         gStandalone.engineOptions.oscPortUDP = value;

  722.         break;

  723. 

  724.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  727.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  728. 

  729.         switch (value)

  730.         {

  731.         case CB::PLUGIN_LADSPA:

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

  733.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  735.             break;

  736.         case CB::PLUGIN_DSSI:

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

  738.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  740.             break;

  741.         case CB::PLUGIN_LV2:

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

  743.                 delete[] gStandalone.engineOptions.pathLV2;

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

  745.             break;

  746.         case CB::PLUGIN_VST2:

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

  748.                 delete[] gStandalone.engineOptions.pathVST2;

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

  750.             break;

  751.         case CB::PLUGIN_VST3:

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

  753.                 delete[] gStandalone.engineOptions.pathVST3;

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

  755.             break;

  756.         case CB::PLUGIN_SF2:

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

  758.                 delete[] gStandalone.engineOptions.pathSF2;

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

  760.             break;

  761.         case CB::PLUGIN_SFZ:

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

  763.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  765.             break;

  766.         }

  767.         break;

  768. 

  769.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  771. 

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

  773.             delete[] gStandalone.engineOptions.binaryDir;

  774. 

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

  776.         break;

  777. 

  778.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  780. 

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

  782.             delete[] gStandalone.engineOptions.resourceDir;

  783. 

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

  785.         break;

  786. 

  787.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  790.         break;

  791. 

  792.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  795.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  797.     }   break;

  798. 

  799. #ifndef CARLA_OS_WIN

  800.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  802. 

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

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

  805. 

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

  807.         break;

  808. 

  809.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  812.         break;

  813. 

  814.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  816. 

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

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

  819. 

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

  821.         break;

  822. 

  823.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  826.         break;

  827. 

  828.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  831.         break;

  832. 

  833.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  836.         break;

  837. #endif

  838. 

  839.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  841.         break;

  842.     }

  843. 

  844.     if (gStandalone.engine != nullptr)

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

  846. }

  847. #endif

  848. 

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

  850. {

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

  852. 

  853.     gStandalone.fileCallback    = func;

  854.     gStandalone.fileCallbackPtr = ptr;

  855. 

  856.     if (gStandalone.engine != nullptr)

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

  858. }

  859. 

  860. // --------------------------------------------------------------------------------------------------------------------

  861. 

  862. bool carla_load_file(const char* filename)

  863. {

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

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

  866. 

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

  868. 

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

  870. }

  871. 

  872. bool carla_load_project(const char* filename)

  873. {

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

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

  876. 

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

  878. 

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

  880. }

  881. 

  882. bool carla_save_project(const char* filename)

  883. {

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

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

  886. 

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

  888. 

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

  890. }

  891. 

  892. #ifndef BUILD_BRIDGE

  893. void carla_clear_project_filename()

  894. {

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

  896. 

  897.     carla_debug("carla_clear_project_filename()");

  898. 

  899.     gStandalone.engine->clearCurrentProjectFilename();

  900. }

  901. 

  902. // --------------------------------------------------------------------------------------------------------------------

  903. 

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

  905. {

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

  907. 

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

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

  910. 

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

  912. }

  913. 

  914. bool carla_patchbay_disconnect(bool external, uint connectionId)

  915. {

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

  917. 

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

  919. 

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

  921. }

  922. 

  923. bool carla_patchbay_refresh(bool external)

  924. {

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

  926. 

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

  928. 

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

  930. }

  931. 

  932. // --------------------------------------------------------------------------------------------------------------------

  933. 

  934. void carla_transport_play()

  935. {

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

  937. 

  938.     carla_debug("carla_transport_play()");

  939. 

  940.     gStandalone.engine->transportPlay();

  941. }

  942. 

  943. void carla_transport_pause()

  944. {

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

  946. 

  947.     carla_debug("carla_transport_pause()");

  948. 

  949.     gStandalone.engine->transportPause();

  950. }

  951. 

  952. void carla_transport_bpm(double bpm)

  953. {

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

  955. 

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

  957. 

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

  959. }

  960. 

  961. void carla_transport_relocate(uint64_t frame)

  962. {

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

  964. 

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

  966. 

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

  968. }

  969. 

  970. uint64_t carla_get_current_transport_frame()

  971. {

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

  973. 

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

  975. }

  976. 

  977. const CarlaTransportInfo* carla_get_transport_info()

  978. {

  979.     static CarlaTransportInfo retTransInfo;

  980.     retTransInfo.clear();

  981. 

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

  983. 

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

  985. 

  986.     retTransInfo.playing = timeInfo.playing;

  987.     retTransInfo.frame   = timeInfo.frame;

  988. 

  989.     if (timeInfo.bbt.valid)

  990.     {

  991.         retTransInfo.bar  = timeInfo.bbt.bar;

  992.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  995.     }

  996. 

  997.     return &retTransInfo;

  998. }

  999. #endif

  1000. 

  1001. // --------------------------------------------------------------------------------------------------------------------

  1002. 

  1003. uint32_t carla_get_current_plugin_count()

  1004. {

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

  1006. 

  1007.     carla_debug("carla_get_current_plugin_count()");

  1008. 

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

  1010. }

  1011. 

  1012. uint32_t carla_get_max_plugin_number()

  1013. {

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

  1015. 

  1016.     carla_debug("carla_get_max_plugin_number()");

  1017. 

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

  1019. }

  1020. 

  1021. // --------------------------------------------------------------------------------------------------------------------

  1022. 

  1023. bool carla_add_plugin(BinaryType btype, PluginType ptype,

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

  1025.                       const void* extraPtr, uint options)

  1026. {

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

  1028. 

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

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

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

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

  1033. 

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

  1035. }

  1036. 

  1037. bool carla_remove_plugin(uint pluginId)

  1038. {

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

  1040. 

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

  1042. 

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

  1044. }

  1045. 

  1046. bool carla_remove_all_plugins()

  1047. {

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

  1049. 

  1050.     carla_debug("carla_remove_all_plugins()");

  1051. 

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

  1053. }

  1054. 

  1055. #ifndef BUILD_BRIDGE

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

  1057. {

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

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

  1060. 

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

  1062. 

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

  1064. }

  1065. 

  1066. bool carla_clone_plugin(uint pluginId)

  1067. {

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

  1069. 

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

  1071. 

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

  1073. }

  1074. 

  1075. bool carla_replace_plugin(uint pluginId)

  1076. {

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

  1078. 

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

  1080. 

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

  1082. }

  1083. 

  1084. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1085. {

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

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

  1088. 

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

  1090. 

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

  1092. }

  1093. #endif

  1094. 

  1095. // --------------------------------------------------------------------------------------------------------------------

  1096. 

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

  1098. {

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

  1100.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr

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

  1102. 

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

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

  1105. 

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

  1107. 

  1108.     return plugin->loadStateFromFile(filename);

  1109. }

  1110. 

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

  1112. {

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

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

  1115. 

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

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

  1118. 

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

  1120. 

  1121.     return plugin->saveStateToFile(filename);

  1122. }

  1123. 

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

  1125. {

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

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

  1128. 

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

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

  1131. 

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

  1133. 

  1134.     return plugin->exportAsLV2(lv2path);

  1135. }

  1136. 

  1137. // --------------------------------------------------------------------------------------------------------------------

  1138. 

  1139. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1140. {

  1141.     static CarlaPluginInfo retInfo;

  1142. 

  1143.     // reset

  1144.     retInfo.type             = CB::PLUGIN_NONE;

  1145.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1146.     retInfo.hints            = 0x0;

  1147.     retInfo.optionsAvailable = 0x0;

  1148.     retInfo.optionsEnabled   = 0x0;

  1149.     retInfo.filename         = gNullCharPtr;

  1150.     retInfo.name             = gNullCharPtr;

  1151.     retInfo.iconName         = gNullCharPtr;

  1152.     retInfo.uniqueId         = 0;

  1153. 

  1154.     // cleanup

  1155.     if (retInfo.label != gNullCharPtr)

  1156.     {

  1157.         delete[] retInfo.label;

  1158.         retInfo.label = gNullCharPtr;

  1159.     }

  1160. 

  1161.     if (retInfo.maker != gNullCharPtr)

  1162.     {

  1163.         delete[] retInfo.maker;

  1164.         retInfo.maker = gNullCharPtr;

  1165.     }

  1166. 

  1167.     if (retInfo.copyright != gNullCharPtr)

  1168.     {

  1169.         delete[] retInfo.copyright;

  1170.         retInfo.copyright = gNullCharPtr;

  1171.     }

  1172. 

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

  1174. 

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

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

  1177. 

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

  1179. 

  1180.     char strBuf[STR_MAX+1];

  1181. 

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

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

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

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

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

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

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

  1189. 

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

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

  1192. 

  1193.     carla_zeroChars(strBuf, STR_MAX+1);

  1194.     plugin->getLabel(strBuf);

  1195.     retInfo.label = carla_strdup_safe(strBuf);

  1196. 

  1197.     carla_zeroChars(strBuf, STR_MAX+1);

  1198.     plugin->getMaker(strBuf);

  1199.     retInfo.maker = carla_strdup_safe(strBuf);

  1200. 

  1201.     carla_zeroChars(strBuf, STR_MAX+1);

  1202.     plugin->getCopyright(strBuf);

  1203.     retInfo.copyright = carla_strdup_safe(strBuf);

  1204. 

  1205.     checkStringPtr(retInfo.filename);

  1206.     checkStringPtr(retInfo.name);

  1207.     checkStringPtr(retInfo.iconName);

  1208.     checkStringPtr(retInfo.label);

  1209.     checkStringPtr(retInfo.maker);

  1210.     checkStringPtr(retInfo.copyright);

  1211. 

  1212.     return &retInfo;

  1213. }

  1214. 

  1215. const CarlaPortCountInfo* carla_get_audio_port_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_audio_port_count_info(%i)", pluginId);

  1226. 

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

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

  1229.     return &retInfo;

  1230. }

  1231. 

  1232. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1233. {

  1234.     static CarlaPortCountInfo retInfo;

  1235.     carla_zeroStruct(retInfo);

  1236. 

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

  1238. 

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

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

  1241. 

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

  1243. 

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

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

  1246.     return &retInfo;

  1247. }

  1248. 

  1249. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1250. {

  1251.     static CarlaPortCountInfo retInfo;

  1252.     carla_zeroStruct(retInfo);

  1253. 

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

  1255. 

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

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

  1258. 

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

  1260. 

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

  1262.     return &retInfo;

  1263. }

  1264. 

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

  1266. {

  1267.     static CarlaParameterInfo retInfo;

  1268. 

  1269.     // reset

  1270.     retInfo.scalePointCount = 0;

  1271. 

  1272.     // cleanup

  1273.     if (retInfo.name != gNullCharPtr)

  1274.     {

  1275.         delete[] retInfo.name;

  1276.         retInfo.name = gNullCharPtr;

  1277.     }

  1278. 

  1279.     if (retInfo.symbol != gNullCharPtr)

  1280.     {

  1281.         delete[] retInfo.symbol;

  1282.         retInfo.symbol = gNullCharPtr;

  1283.     }

  1284. 

  1285.     if (retInfo.unit != gNullCharPtr)

  1286.     {

  1287.         delete[] retInfo.unit;

  1288.         retInfo.unit = gNullCharPtr;

  1289.     }

  1290. 

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

  1292. 

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

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

  1295. 

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

  1297. 

  1298.     char strBuf[STR_MAX+1];

  1299. 

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

  1301. 

  1302.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1304.     retInfo.name = carla_strdup_safe(strBuf);

  1305. 

  1306.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1308.     retInfo.symbol = carla_strdup_safe(strBuf);

  1309. 

  1310.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1312.     retInfo.unit = carla_strdup_safe(strBuf);

  1313. 

  1314.     checkStringPtr(retInfo.name);

  1315.     checkStringPtr(retInfo.symbol);

  1316.     checkStringPtr(retInfo.unit);

  1317. 

  1318.     return &retInfo;

  1319. }

  1320. 

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

  1322. {

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

  1324. 

  1325.     static CarlaScalePointInfo retInfo;

  1326. 

  1327.     // reset

  1328.     retInfo.value = 0.0f;

  1329. 

  1330.     // cleanup

  1331.     if (retInfo.label != gNullCharPtr)

  1332.     {

  1333.         delete[] retInfo.label;

  1334.         retInfo.label = gNullCharPtr;

  1335.     }

  1336. 

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

  1338. 

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

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

  1341. 

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

  1343. 

  1344.     char strBuf[STR_MAX+1];

  1345. 

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

  1347. 

  1348.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1350.     retInfo.label = carla_strdup_safe(strBuf);

  1351. 

  1352.     checkStringPtr(retInfo.label);

  1353. 

  1354.     return &retInfo;

  1355. }

  1356. 

  1357. // --------------------------------------------------------------------------------------------------------------------

  1358. 

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

  1360. {

  1361.     static ParameterData retParamData;

  1362. 

  1363.     // reset

  1364.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1365.     retParamData.hints       = 0x0;

  1366.     retParamData.index       = CB::PARAMETER_NULL;

  1367.     retParamData.rindex      = -1;

  1368.     retParamData.midiCC      = -1;

  1369.     retParamData.midiChannel = 0;

  1370. 

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

  1372. 

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

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

  1375. 

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

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

  1378. 

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

  1380.     retParamData.type        = pluginParamData.type;

  1381.     retParamData.hints       = pluginParamData.hints;

  1382.     retParamData.index       = pluginParamData.index;

  1383.     retParamData.rindex      = pluginParamData.rindex;

  1384.     retParamData.midiCC      = pluginParamData.midiCC;

  1385.     retParamData.midiChannel = pluginParamData.midiChannel;

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

  1387. }

  1388. 

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

  1390. {

  1391.     static ParameterRanges retParamRanges;

  1392. 

  1393.     // reset

  1394.     retParamRanges.def       = 0.0f;

  1395.     retParamRanges.min       = 0.0f;

  1396.     retParamRanges.max       = 1.0f;

  1397.     retParamRanges.step      = 0.01f;

  1398.     retParamRanges.stepSmall = 0.0001f;

  1399.     retParamRanges.stepLarge = 0.1f;

  1400. 

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

  1402. 

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

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

  1405. 

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

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

  1408. 

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

  1410.     retParamRanges.def       = pluginParamRanges.def;

  1411.     retParamRanges.min       = pluginParamRanges.min;

  1412.     retParamRanges.max       = pluginParamRanges.max;

  1413.     retParamRanges.step      = pluginParamRanges.step;

  1414.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1415.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1416.     return &pluginParamRanges;

  1417. }

  1418. 

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

  1420. {

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

  1422. 

  1423.     // reset

  1424.     retMidiProgData.bank    = 0;

  1425.     retMidiProgData.program = 0;

  1426. 

  1427.     if (retMidiProgData.name != gNullCharPtr)

  1428.     {

  1429.         delete[] retMidiProgData.name;

  1430.         retMidiProgData.name = gNullCharPtr;

  1431.     }

  1432. 

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

  1434. 

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

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

  1437. 

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

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

  1440. 

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

  1442.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1443.     retMidiProgData.program = pluginMidiProgData.program;

  1444. 

  1445.     if (pluginMidiProgData.name != nullptr)

  1446.     {

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

  1448.         checkStringPtr(retMidiProgData.name);

  1449.     }

  1450.     else

  1451.     {

  1452.         retMidiProgData.name = gNullCharPtr;

  1453.     }

  1454. 

  1455.     return &retMidiProgData;

  1456. }

  1457. 

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

  1459. {

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

  1461. 

  1462.     // reset

  1463.     if (retCustomData.type != gNullCharPtr)

  1464.     {

  1465.         delete[] retCustomData.type;

  1466.         retCustomData.type = gNullCharPtr;

  1467.     }

  1468. 

  1469.     if (retCustomData.key != gNullCharPtr)

  1470.     {

  1471.         delete[] retCustomData.key;

  1472.         retCustomData.key = gNullCharPtr;

  1473.     }

  1474. 

  1475.     if (retCustomData.value != gNullCharPtr)

  1476.     {

  1477.         delete[] retCustomData.value;

  1478.         retCustomData.value = gNullCharPtr;

  1479.     }

  1480. 

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

  1482. 

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

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

  1485. 

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

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

  1488. 

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

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

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

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

  1493.     checkStringPtr(retCustomData.type);

  1494.     checkStringPtr(retCustomData.key);

  1495.     checkStringPtr(retCustomData.value);

  1496.     return &retCustomData;

  1497. }

  1498. 

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

  1500. {

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

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

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

  1504. 

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

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

  1507. 

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

  1509. 

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

  1511. 

  1512.     if (count == 0)

  1513.         return gNullCharPtr;

  1514. 

  1515.     static CarlaString customDataValue;

  1516. 

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

  1518.     {

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

  1520. 

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

  1522.             continue;

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

  1524.             continue;

  1525. 

  1526.         customDataValue = pluginCustomData.value;

  1527.         return customDataValue.buffer();

  1528.     }

  1529. 

  1530.     return gNullCharPtr;

  1531. }

  1532. 

  1533. const char* carla_get_chunk_data(uint pluginId)

  1534. {

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

  1536. 

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

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

  1539. 

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

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

  1542. 

  1543.     void* data = nullptr;

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

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

  1546. 

  1547.     static CarlaString chunkData;

  1548. 

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

  1550.     return chunkData.buffer();

  1551. }

  1552. 

  1553. // --------------------------------------------------------------------------------------------------------------------

  1554. 

  1555. uint32_t carla_get_parameter_count(uint pluginId)

  1556. {

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

  1558. 

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

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

  1561. 

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

  1563.     return plugin->getParameterCount();

  1564. }

  1565. 

  1566. uint32_t carla_get_program_count(uint pluginId)

  1567. {

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

  1569. 

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

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

  1572. 

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

  1574.     return plugin->getProgramCount();

  1575. }

  1576. 

  1577. uint32_t carla_get_midi_program_count(uint pluginId)

  1578. {

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

  1580. 

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

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

  1583. 

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

  1585.     return plugin->getMidiProgramCount();

  1586. }

  1587. 

  1588. uint32_t carla_get_custom_data_count(uint pluginId)

  1589. {

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

  1591. 

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

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

  1594. 

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

  1596.     return plugin->getCustomDataCount();

  1597. }

  1598. 

  1599. // --------------------------------------------------------------------------------------------------------------------

  1600. 

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

  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_parameter_text(%i, %i)", pluginId, parameterId);

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

  1610. 

  1611.     static char textBuf[STR_MAX+1];

  1612.     carla_zeroChars(textBuf, STR_MAX+1);

  1613. 

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

  1615.     return textBuf;

  1616. }

  1617. 

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

  1619. {

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

  1621. 

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

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

  1624. 

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

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

  1627. 

  1628.     static char programName[STR_MAX+1];

  1629.     carla_zeroChars(programName, STR_MAX+1);

  1630. 

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

  1632.     return programName;

  1633. }

  1634. 

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

  1636. {

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

  1638. 

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

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

  1641. 

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

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

  1644. 

  1645.     static char midiProgramName[STR_MAX+1];

  1646.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1647. 

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

  1649.     return midiProgramName;

  1650. }

  1651. 

  1652. const char* carla_get_real_plugin_name(uint pluginId)

  1653. {

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

  1655. 

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

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

  1658. 

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

  1660.     static char realPluginName[STR_MAX+1];

  1661.     carla_zeroChars(realPluginName, STR_MAX+1);

  1662. 

  1663.     plugin->getRealName(realPluginName);

  1664.     return realPluginName;

  1665. }

  1666. 

  1667. // --------------------------------------------------------------------------------------------------------------------

  1668. 

  1669. int32_t carla_get_current_program_index(uint pluginId)

  1670. {

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

  1672. 

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

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

  1675. 

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

  1677.     return plugin->getCurrentProgram();

  1678. }

  1679. 

  1680. int32_t carla_get_current_midi_program_index(uint pluginId)

  1681. {

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

  1683. 

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

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

  1686. 

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

  1688.     return plugin->getCurrentMidiProgram();

  1689. }

  1690. 

  1691. // --------------------------------------------------------------------------------------------------------------------

  1692. 

  1693. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1694. {

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

  1696. 

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

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

  1699. 

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

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

  1702. 

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

  1704. }

  1705. 

  1706. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1707. {

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

  1709. 

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

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

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

  1713. 

  1714.     return plugin->getParameterValue(parameterId);

  1715. }

  1716. 

  1717. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1718. {

  1719. #ifdef BUILD_BRIDGE

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

  1721. #else

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

  1723. #endif

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

  1725. 

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

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

  1728. 

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

  1730.     return plugin->getInternalParameterValue(parameterId);

  1731. }

  1732. 

  1733. // --------------------------------------------------------------------------------------------------------------------

  1734. 

  1735. const float* carla_get_peak_values(uint pluginId)

  1736. {

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

  1738. 

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

  1740. }

  1741. 

  1742. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1743. {

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

  1745. 

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

  1747. }

  1748. 

  1749. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1750. {

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

  1752. 

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

  1754. }

  1755. 

  1756. // --------------------------------------------------------------------------------------------------------------------

  1757. 

  1758. CARLA_BACKEND_START_NAMESPACE

  1759. 

  1760. // defined in CarlaPluginLV2.cpp

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

  1762. 

  1763. CARLA_BACKEND_END_NAMESPACE

  1764. 

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

  1766. {

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

  1768. 

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

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

  1771. 

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

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

  1774. 

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

  1776. }

  1777. 

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

  1779. 

  1780. void carla_set_active(uint pluginId, bool onOff)

  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_active(%i, %s)", pluginId, bool2str(onOff));

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

  1789. }

  1790. 

  1791. #ifndef BUILD_BRIDGE

  1792. void carla_set_drywet(uint pluginId, float value)

  1793. {

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

  1795. 

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

  1797.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1798. 

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

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

  1801. }

  1802. 

  1803. void carla_set_volume(uint pluginId, float value)

  1804. {

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

  1806. 

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

  1808.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1809. 

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

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

  1812. }

  1813. 

  1814. void carla_set_balance_left(uint pluginId, float value)

  1815. {

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

  1817. 

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

  1819.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1820. 

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

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

  1823. }

  1824. 

  1825. void carla_set_balance_right(uint pluginId, float value)

  1826. {

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

  1828. 

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

  1830.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1831. 

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

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

  1834. }

  1835. 

  1836. void carla_set_panning(uint pluginId, float value)

  1837. {

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

  1839. 

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

  1841.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1842. 

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

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

  1845. }

  1846. 

  1847. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1848. {

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

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

  1851. 

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

  1853.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1854. 

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

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

  1857. }

  1858. #endif

  1859. 

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

  1861. {

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

  1863. 

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

  1865.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1866. 

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

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

  1869. }

  1870. 

  1871. // --------------------------------------------------------------------------------------------------------------------

  1872. 

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

  1874. {

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

  1876. 

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

  1878.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1879. 

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

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

  1882. 

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

  1884. }

  1885. 

  1886. #ifndef BUILD_BRIDGE

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

  1888. {

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

  1890.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1891. 

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

  1893.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1894. 

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

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

  1897. 

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

  1899. }

  1900. 

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

  1902. {

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

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

  1905. 

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

  1907.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1908. 

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

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

  1911. 

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

  1913. }

  1914. #endif

  1915. 

  1916. // --------------------------------------------------------------------------------------------------------------------

  1917. 

  1918. void carla_set_program(uint pluginId, uint32_t programId)

  1919. {

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

  1921. 

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

  1923.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1924. 

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

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

  1927. 

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

  1929. }

  1930. 

  1931. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1932. {

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

  1934. 

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

  1936.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1937. 

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

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

  1940. 

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

  1942. }

  1943. 

  1944. // --------------------------------------------------------------------------------------------------------------------

  1945. 

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

  1947. {

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

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

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

  1951.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1952. 

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

  1954.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1955. 

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

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

  1958. }

  1959. 

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

  1961. {

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

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

  1964. 

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

  1966.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1967. 

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

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

  1970. 

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

  1972. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  1974. #else

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

  1976. #endif

  1977. }

  1978. 

  1979. // --------------------------------------------------------------------------------------------------------------------

  1980. 

  1981. void carla_prepare_for_save(uint pluginId)

  1982. {

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

  1984. 

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

  1986.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1987. 

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

  1989.     return plugin->prepareForSave();

  1990. }

  1991. 

  1992. void carla_reset_parameters(uint pluginId)

  1993. {

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

  1995. 

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

  1997.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1998. 

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

  2000.     return plugin->resetParameters();

  2001. }

  2002. 

  2003. void carla_randomize_parameters(uint pluginId)

  2004. {

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

  2006. 

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

  2008.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2009. 

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

  2011.     return plugin->randomizeParameters();

  2012. }

  2013. 

  2014. #ifndef BUILD_BRIDGE

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

  2016. {

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

  2018. 

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

  2020.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2021. 

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

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

  2024. }

  2025. #endif

  2026. 

  2027. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2028. {

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

  2030. 

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

  2032.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2033. 

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

  2035.     return plugin->showCustomUI(yesNo);

  2036. }

  2037. 

  2038. // --------------------------------------------------------------------------------------------------------------------

  2039. 

  2040. uint32_t carla_get_buffer_size()

  2041. {

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

  2043. 

  2044.     carla_debug("carla_get_buffer_size()");

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

  2046. }

  2047. 

  2048. double carla_get_sample_rate()

  2049. {

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

  2051. 

  2052.     carla_debug("carla_get_sample_rate()");

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

  2054. }

  2055. 

  2056. // --------------------------------------------------------------------------------------------------------------------

  2057. 

  2058. const char* carla_get_last_error()

  2059. {

  2060.     carla_debug("carla_get_last_error()");

  2061. 

  2062.     if (gStandalone.engine != nullptr)

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

  2064. 

  2065.     return gStandalone.lastError;

  2066. }

  2067. 

  2068. const char* carla_get_host_osc_url_tcp()

  2069. {

  2070.     carla_debug("carla_get_host_osc_url_tcp()");

  2071. 

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

  2073.     if (gStandalone.engine == nullptr)

  2074.     {

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

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

  2077.         return gNullCharPtr;

  2078.     }

  2079. 

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

  2081. 

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

  2083.         return path;

  2084. 

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

  2086.     return notAvailable;

  2087. #else

  2088.     return gNullCharPtr;

  2089. #endif

  2090. }

  2091. 

  2092. const char* carla_get_host_osc_url_udp()

  2093. {

  2094.     carla_debug("carla_get_host_osc_url_udp()");

  2095. 

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

  2097.     if (gStandalone.engine == nullptr)

  2098.     {

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

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

  2101.         return gNullCharPtr;

  2102.     }

  2103. 

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

  2105. 

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

  2107.         return path;

  2108. 

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

  2110.     return notAvailable;

  2111. #else

  2112.     return gNullCharPtr;

  2113. #endif

  2114. }

  2115. 

  2116. // --------------------------------------------------------------------------------------------------------------------

  2117. 

  2118. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2119. #include "CarlaPluginUI.cpp"

  2120. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2121. 

  2122. #include "CarlaDssiUtils.cpp"

  2123. #include "CarlaMacUtils.cpp"

  2124. #include "CarlaPatchbayUtils.cpp"

  2125. #include "CarlaPipeUtils.cpp"

  2126. #include "CarlaStateUtils.cpp"

  2127. 

  2128. // --------------------------------------------------------------------------------------------------------------------