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.
4795 Commits
17 Branches
457MB
Tree: 699fc9d714
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '699fc9d714'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2115 lines
74KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngine.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. 

  30. #ifdef CARLA_OS_UNIX

  31. # include "CarlaLibUtils.hpp"

  32. #endif

  33. 

  34. #ifdef BUILD_BRIDGE

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

  36. #else

  37. # include "CarlaLogThread.hpp"

  38. #endif

  39. 

  40. #ifdef USING_JUCE

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

  42. #  pragma GCC diagnostic push

  43. #  pragma GCC diagnostic ignored "-Wconversion"

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

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

  46. #  pragma GCC diagnostic ignored "-Wundef"

  47. # endif

  48. 

  49. # include "AppConfig.h"

  50. # include "juce_events/juce_events.h"

  51. 

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

  53. #  pragma GCC diagnostic pop

  54. # endif

  55. #endif

  56. 

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

  58.     if (! (cond)) {                                              \

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

  60.         gStandalone.lastError = msg;                             \

  61.         return ret;                                              \

  62.     }

  63. 

  64. namespace CB = CarlaBackend;

  65. using CB::EngineOptions;

  66. 

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

  68. // Single, standalone engine

  69. 

  70. struct CarlaBackendStandalone {

  71.     CarlaEngine*       engine;

  72.     EngineCallbackFunc engineCallback;

  73.     void*              engineCallbackPtr;

  74. #ifndef BUILD_BRIDGE

  75.     EngineOptions      engineOptions;

  76.     CarlaLogThread     logThread;

  77.     bool               logThreadEnabled;

  78. #endif

  79. 

  80.     FileCallbackFunc fileCallback;

  81.     void*            fileCallbackPtr;

  82. 

  83.     CarlaString lastError;

  84. 

  85.     CarlaBackendStandalone() noexcept

  86.         : engine(nullptr),

  87.           engineCallback(nullptr),

  88.           engineCallbackPtr(nullptr),

  89. #ifndef BUILD_BRIDGE

  90.           engineOptions(),

  91.           logThread(),

  92.           logThreadEnabled(false),

  93. #endif

  94.           fileCallback(nullptr),

  95.           fileCallbackPtr(nullptr),

  96.           lastError() {}

  97. 

  98.     ~CarlaBackendStandalone() noexcept

  99.     {

  100.         CARLA_SAFE_ASSERT(engine == nullptr);

  101.     }

  102. 

  103.     CARLA_PREVENT_HEAP_ALLOCATION

  104.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  105. };

  106. 

  107. CarlaBackendStandalone gStandalone;

  108. 

  109. #ifdef CARLA_OS_UNIX

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

  111. // Thread-safe fftw

  112. 

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

  114. 

  115. class ThreadSafeFFTW

  116. {

  117. public:

  118.     struct Deinitializer {

  119.         Deinitializer(ThreadSafeFFTW& s)

  120.             : tsfftw(s) {}

  121. 

  122.         ~Deinitializer()

  123.         {

  124.             tsfftw.deinit();

  125.         }

  126. 

  127.         ThreadSafeFFTW& tsfftw;

  128.     };

  129. 

  130.     ThreadSafeFFTW()

  131.         : libfftw3(nullptr),

  132.           libfftw3f(nullptr),

  133.           libfftw3l(nullptr),

  134.           libfftw3q(nullptr) {}

  135. 

  136.     ~ThreadSafeFFTW()

  137.     {

  138.         CARLA_SAFE_ASSERT(libfftw3 == nullptr);

  139.     }

  140. 

  141.     void init()

  142.     {

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

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

  145.                 func();

  146. 

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

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

  149.                 func();

  150. 

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

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

  153.                 func();

  154. 

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

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

  157.                 func();

  158.     }

  159. 

  160.     void deinit()

  161.     {

  162.         if (libfftw3 != nullptr)

  163.         {

  164.             lib_close(libfftw3);

  165.             libfftw3 = nullptr;

  166.         }

  167. 

  168.         if (libfftw3f != nullptr)

  169.         {

  170.             lib_close(libfftw3f);

  171.             libfftw3f = nullptr;

  172.         }

  173. 

  174.         if (libfftw3l != nullptr)

  175.         {

  176.             lib_close(libfftw3l);

  177.             libfftw3l = nullptr;

  178.         }

  179. 

  180.         if (libfftw3q != nullptr)

  181.         {

  182.             lib_close(libfftw3q);

  183.             libfftw3q = nullptr;

  184.         }

  185.     }

  186. 

  187. private:

  188.     lib_t libfftw3;

  189.     lib_t libfftw3f;

  190.     lib_t libfftw3l;

  191.     lib_t libfftw3q;

  192. 

  193.     CARLA_DECLARE_NON_COPY_CLASS(ThreadSafeFFTW)

  194. };

  195. 

  196. static ThreadSafeFFTW sThreadSafeFFTW;

  197. #endif

  198. 

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

  200. // API

  201. 

  202. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  203. #include "CarlaHostCommon.cpp"

  204. #undef CARLA_COMMON_NEED_CHECKSTRINGPTR

  205. 

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

  207. 

  208. uint carla_get_engine_driver_count()

  209. {

  210.     carla_debug("carla_get_engine_driver_count()");

  211. 

  212.     return CarlaEngine::getDriverCount();

  213. }

  214. 

  215. const char* carla_get_engine_driver_name(uint index)

  216. {

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

  218. 

  219.     return CarlaEngine::getDriverName(index);

  220. }

  221. 

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

  223. {

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

  225. 

  226.     return CarlaEngine::getDriverDeviceNames(index);

  227. }

  228. 

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

  230. {

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

  232. 

  233.     static EngineDriverDeviceInfo retDevInfo;

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

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

  236. 

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

  238. 

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

  240.     {

  241.         retDevInfo.hints       =  devInfo->hints;

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

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

  244.     }

  245.     else

  246.     {

  247.         retDevInfo.hints       = 0x0;

  248.         retDevInfo.bufferSizes = nullBufferSizes;

  249.         retDevInfo.sampleRates = nullSampleRates;

  250.     }

  251. 

  252.     return &retDevInfo;

  253. }

  254. 

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

  256. 

  257. CarlaEngine* carla_get_engine()

  258. {

  259.     carla_debug("carla_get_engine()");

  260. 

  261.     return gStandalone.engine;

  262. }

  263. 

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

  265. 

  266. static void carla_engine_init_common(CarlaEngine* const engine)

  267. {

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

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

  270. 

  271. #ifdef BUILD_BRIDGE

  272.     using water::File;

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

  274. 

  275.     /*

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

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

  278. 

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

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

  281. 

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

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

  284.     */

  285. 

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

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

  288. 

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

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

  291. 

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

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

  294. 

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

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

  297. 

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

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

  300. 

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

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

  303. 

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

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

  306. 

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

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

  309. 

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

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

  312. 

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

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

  315. 

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

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

  318.     else

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

  320. 

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

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

  323.     else

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

  325. 

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

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

  328. 

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

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

  331. #else

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

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

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

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

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

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

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

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

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

  341. 

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

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

  344. 

  345.     engine->setOption(CB::ENGINE_OPTION_OSC_ENABLE,   gStandalone.engineOptions.oscEnabled, nullptr);

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

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

  348. 

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

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

  351. 

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

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

  354. 

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

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

  357. 

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

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

  360. 

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

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

  363. 

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

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

  366. 

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

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

  369. 

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

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

  372. 

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

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

  375. 

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

  377. 

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

  379.     {

  380.         char strBuf[STR_MAX+1];

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

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

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

  384.     }

  385.     else

  386.     {

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

  388.     }

  389. 

  390. # ifndef CARLA_OS_WIN

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

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

  393. 

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

  395. 

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

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

  398. 

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

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

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

  402. # endif

  403. #endif

  404. }

  405. 

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

  407. {

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

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

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

  411. 

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

  413. 

  414. #ifdef CARLA_OS_WIN

  415.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  416. #endif

  417. 

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

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

  420. 

  421.     gStandalone.engine = engine;

  422. 

  423. #ifdef BUILD_BRIDGE

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

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

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

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

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

  429. #else

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

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

  432. #endif

  433. 

  434. #ifdef USING_JUCE

  435.     juce::initialiseJuce_GUI();

  436. #endif

  437. 

  438.     carla_engine_init_common(engine);

  439. 

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

  441.     {

  442. #ifndef BUILD_BRIDGE

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

  444.             gStandalone.logThread.init();

  445. #endif

  446. #ifdef CARLA_OS_UNIX

  447.         sThreadSafeFFTW.init();

  448. #endif

  449.         gStandalone.lastError = "No error";

  450.         return true;

  451.     }

  452.     else

  453.     {

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

  455.         gStandalone.engine = nullptr;

  456. #ifdef USING_JUCE

  457.         juce::shutdownJuce_GUI();

  458. #endif

  459.         return false;

  460.     }

  461. }

  462. 

  463. #ifdef BUILD_BRIDGE

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

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

  466. {

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

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

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

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

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

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

  473. 

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

  475. 

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

  477.                                                              rtClientBaseName,

  478.                                                              nonRtClientBaseName,

  479.                                                              nonRtServerBaseName));

  480. 

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

  482. 

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

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

  485. 

  486.     carla_engine_init_common(engine);

  487. 

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

  489.     {

  490.         gStandalone.lastError = "No error";

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

  492.         return true;

  493.     }

  494.     else

  495.     {

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

  497.         return false;

  498.     }

  499. }

  500. #endif

  501. 

  502. bool carla_engine_close()

  503. {

  504.     carla_debug("carla_engine_close()");

  505. 

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

  507. 

  508. #ifdef CARLA_OS_UNIX

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

  510. #endif

  511. 

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

  513.     gStandalone.engine = nullptr;

  514. 

  515.     engine->setAboutToClose();

  516.     engine->removeAllPlugins();

  517. 

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

  519. 

  520.     if (! closed)

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

  522. 

  523. #ifndef BUILD_BRIDGE

  524.     gStandalone.logThread.stop();

  525. # ifdef USING_JUCE

  526.     juce::shutdownJuce_GUI();

  527. # endif

  528. #endif

  529. 

  530.     return closed;

  531. }

  532. 

  533. void carla_engine_idle()

  534. {

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

  536. 

  537.     gStandalone.engine->idle();

  538. 

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

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

  541.     CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  542. 

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

  544. #endif

  545. }

  546. 

  547. bool carla_is_engine_running()

  548. {

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

  550. }

  551. 

  552. const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info()

  553. {

  554.     static CarlaRuntimeEngineInfo retInfo;

  555. 

  556.     // reset

  557.     retInfo.load = 0.0f;

  558.     retInfo.xruns = 0;

  559. 

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

  561. 

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

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

  564. 

  565.     return &retInfo;

  566. }

  567. 

  568. void carla_clear_engine_xruns()

  569. {

  570.     if (gStandalone.engine != nullptr)

  571.         gStandalone.engine->clearXruns();

  572. }

  573. 

  574. void carla_cancel_engine_action()

  575. {

  576.     if (gStandalone.engine != nullptr)

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

  578. }

  579. 

  580. bool carla_set_engine_about_to_close()

  581. {

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

  583.     carla_debug("carla_set_engine_about_to_close()");

  584. 

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

  586. }

  587. 

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

  589. {

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

  591. 

  592.     gStandalone.engineCallback    = func;

  593.     gStandalone.engineCallbackPtr = ptr;

  594. 

  595. #ifndef BUILD_BRIDGE

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

  597. #endif

  598. 

  599.     if (gStandalone.engine != nullptr)

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

  601. }

  602. 

  603. #ifndef BUILD_BRIDGE

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

  605. {

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

  607. 

  608.     switch (option)

  609.     {

  610.     case CB::ENGINE_OPTION_DEBUG:

  611.         break;

  612. 

  613.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  616.         break;

  617. 

  618.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

  620. 

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

  622.         {

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

  624.             if (gStandalone.engineCallback != nullptr)

  625.                 gStandalone.engineCallback(gStandalone.engineCallbackPtr,

  626.                                            CB::ENGINE_CALLBACK_TRANSPORT_MODE_CHANGED,

  627.                                            0,

  628.                                            CB::ENGINE_TRANSPORT_MODE_JACK,

  629.                                            0, 0, 0.0f,

  630.                                            gStandalone.engineOptions.transportExtra);

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

  632.         }

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

  634. 

  635.         delete[] gStandalone.engineOptions.transportExtra;

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

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

  638.         else

  639.             gStandalone.engineOptions.transportExtra = nullptr;

  640.         break;

  641. 

  642.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  645.         break;

  646. 

  647.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  650.         break;

  651. 

  652.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  655.         break;

  656. 

  657.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  660.         break;

  661. 

  662.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  663.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  665.         break;

  666. 

  667.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  668.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  670.         break;

  671. 

  672.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  673.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  675.         break;

  676. 

  677.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  678.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  680.         break;

  681. 

  682.     case CB::ENGINE_OPTION_AUDIO_TRIPLE_BUFFER:

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

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

  685.         break;

  686. 

  687.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  688.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  689. 

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

  691.             delete[] gStandalone.engineOptions.audioDevice;

  692. 

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

  694.         break;

  695. 

  696.     case CB::ENGINE_OPTION_OSC_ENABLE:

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

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

  699.         break;

  700. 

  701.     case CB::ENGINE_OPTION_OSC_PORT_TCP:

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

  703.         gStandalone.engineOptions.oscPortTCP = value;

  704.         break;

  705. 

  706.     case CB::ENGINE_OPTION_OSC_PORT_UDP:

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

  708.         gStandalone.engineOptions.oscPortUDP = value;

  709.         break;

  710. 

  711.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  714.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  715. 

  716.         switch (value)

  717.         {

  718.         case CB::PLUGIN_LADSPA:

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

  720.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  722.             break;

  723.         case CB::PLUGIN_DSSI:

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

  725.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  727.             break;

  728.         case CB::PLUGIN_LV2:

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

  730.                 delete[] gStandalone.engineOptions.pathLV2;

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

  732.             break;

  733.         case CB::PLUGIN_VST2:

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

  735.                 delete[] gStandalone.engineOptions.pathVST2;

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

  737.             break;

  738.         case CB::PLUGIN_VST3:

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

  740.                 delete[] gStandalone.engineOptions.pathVST3;

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

  742.             break;

  743.         case CB::PLUGIN_SF2:

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

  745.                 delete[] gStandalone.engineOptions.pathSF2;

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

  747.             break;

  748.         case CB::PLUGIN_SFZ:

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

  750.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  752.             break;

  753.         }

  754.         break;

  755. 

  756.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  758. 

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

  760.             delete[] gStandalone.engineOptions.binaryDir;

  761. 

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

  763.         break;

  764. 

  765.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  767. 

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

  769.             delete[] gStandalone.engineOptions.resourceDir;

  770. 

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

  772.         break;

  773. 

  774.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  777.         break;

  778. 

  779.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID: {

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

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

  782.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  784.     }   break;

  785. 

  786. #ifndef CARLA_OS_WIN

  787.     case CB::ENGINE_OPTION_WINE_EXECUTABLE:

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

  789. 

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

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

  792. 

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

  794.         break;

  795. 

  796.     case CB::ENGINE_OPTION_WINE_AUTO_PREFIX:

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

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

  799.         break;

  800. 

  801.     case CB::ENGINE_OPTION_WINE_FALLBACK_PREFIX:

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

  803. 

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

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

  806. 

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

  808.         break;

  809. 

  810.     case CB::ENGINE_OPTION_WINE_RT_PRIO_ENABLED:

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

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

  813.         break;

  814. 

  815.     case CB::ENGINE_OPTION_WINE_BASE_RT_PRIO:

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

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

  818.         break;

  819. 

  820.     case CB::ENGINE_OPTION_WINE_SERVER_RT_PRIO:

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

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

  823.         break;

  824. #endif

  825. 

  826.     case CB::ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT:

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

  828.         break;

  829.     }

  830. 

  831.     if (gStandalone.engine != nullptr)

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

  833. }

  834. #endif

  835. 

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

  837. {

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

  839. 

  840.     gStandalone.fileCallback    = func;

  841.     gStandalone.fileCallbackPtr = ptr;

  842. 

  843.     if (gStandalone.engine != nullptr)

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

  845. }

  846. 

  847. // --------------------------------------------------------------------------------------------------------------------

  848. 

  849. bool carla_load_file(const char* filename)

  850. {

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

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

  853. 

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

  855. 

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

  857. }

  858. 

  859. bool carla_load_project(const char* filename)

  860. {

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

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

  863. 

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

  865. 

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

  867. }

  868. 

  869. bool carla_save_project(const char* filename)

  870. {

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

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

  873. 

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

  875. 

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

  877. }

  878. 

  879. #ifndef BUILD_BRIDGE

  880. void carla_clear_project_filename()

  881. {

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

  883. 

  884.     carla_debug("carla_clear_project_filename()");

  885. 

  886.     gStandalone.engine->clearCurrentProjectFilename();

  887. }

  888. 

  889. // --------------------------------------------------------------------------------------------------------------------

  890. 

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

  892. {

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

  894. 

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

  896. 

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

  898. }

  899. 

  900. bool carla_patchbay_disconnect(uint connectionId)

  901. {

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

  903. 

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

  905. 

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

  907. }

  908. 

  909. bool carla_patchbay_refresh(bool external)

  910. {

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

  912. 

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

  914. 

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

  916. }

  917. 

  918. // --------------------------------------------------------------------------------------------------------------------

  919. 

  920. void carla_transport_play()

  921. {

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

  923. 

  924.     carla_debug("carla_transport_play()");

  925. 

  926.     gStandalone.engine->transportPlay();

  927. }

  928. 

  929. void carla_transport_pause()

  930. {

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

  932. 

  933.     carla_debug("carla_transport_pause()");

  934. 

  935.     gStandalone.engine->transportPause();

  936. }

  937. 

  938. void carla_transport_bpm(double bpm)

  939. {

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

  941. 

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

  943. 

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

  945. }

  946. 

  947. void carla_transport_relocate(uint64_t frame)

  948. {

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

  950. 

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

  952. 

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

  954. }

  955. 

  956. uint64_t carla_get_current_transport_frame()

  957. {

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

  959. 

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

  961. }

  962. 

  963. const CarlaTransportInfo* carla_get_transport_info()

  964. {

  965.     static CarlaTransportInfo retTransInfo;

  966.     retTransInfo.clear();

  967. 

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

  969. 

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

  971. 

  972.     retTransInfo.playing = timeInfo.playing;

  973.     retTransInfo.frame   = timeInfo.frame;

  974. 

  975.     if (timeInfo.bbt.valid)

  976.     {

  977.         retTransInfo.bar  = timeInfo.bbt.bar;

  978.         retTransInfo.beat = timeInfo.bbt.beat;

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

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

  981.     }

  982. 

  983.     return &retTransInfo;

  984. }

  985. #endif

  986. 

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

  988. 

  989. uint32_t carla_get_current_plugin_count()

  990. {

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

  992. 

  993.     carla_debug("carla_get_current_plugin_count()");

  994. 

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

  996. }

  997. 

  998. uint32_t carla_get_max_plugin_number()

  999. {

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

  1001. 

  1002.     carla_debug("carla_get_max_plugin_number()");

  1003. 

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

  1005. }

  1006. 

  1007. // --------------------------------------------------------------------------------------------------------------------

  1008. 

  1009. bool carla_add_plugin(BinaryType btype, PluginType ptype,

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

  1011.                       const void* extraPtr, uint options)

  1012. {

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

  1014. 

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

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

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

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

  1019. 

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

  1021. }

  1022. 

  1023. bool carla_remove_plugin(uint pluginId)

  1024. {

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

  1026. 

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

  1028. 

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

  1030. }

  1031. 

  1032. bool carla_remove_all_plugins()

  1033. {

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

  1035. 

  1036.     carla_debug("carla_remove_all_plugins()");

  1037. 

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

  1039. }

  1040. 

  1041. #ifndef BUILD_BRIDGE

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

  1043. {

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

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

  1046. 

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

  1048. 

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

  1050. }

  1051. 

  1052. bool carla_clone_plugin(uint pluginId)

  1053. {

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

  1055. 

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

  1057. 

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

  1059. }

  1060. 

  1061. bool carla_replace_plugin(uint pluginId)

  1062. {

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

  1064. 

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

  1066. 

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

  1068. }

  1069. 

  1070. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1071. {

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

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

  1074. 

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

  1076. 

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

  1078. }

  1079. #endif

  1080. 

  1081. // --------------------------------------------------------------------------------------------------------------------

  1082. 

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

  1084. {

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

  1086.     CARLA_SAFE_ASSERT_WITH_LAST_ERROR_RETURN(gStandalone.engine != nullptr

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

  1088. 

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

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

  1091. 

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

  1093. 

  1094.     return plugin->loadStateFromFile(filename);

  1095. }

  1096. 

  1097. bool carla_save_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, "Engine is not initialized", false);

  1101. 

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

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

  1104. 

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

  1106. 

  1107.     return plugin->saveStateToFile(filename);

  1108. }

  1109. 

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

  1111. {

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

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

  1114. 

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

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

  1117. 

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

  1119. 

  1120.     return plugin->exportAsLV2(lv2path);

  1121. }

  1122. 

  1123. // --------------------------------------------------------------------------------------------------------------------

  1124. 

  1125. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1126. {

  1127.     static CarlaPluginInfo retInfo;

  1128. 

  1129.     // reset

  1130.     retInfo.type             = CB::PLUGIN_NONE;

  1131.     retInfo.category         = CB::PLUGIN_CATEGORY_NONE;

  1132.     retInfo.hints            = 0x0;

  1133.     retInfo.optionsAvailable = 0x0;

  1134.     retInfo.optionsEnabled   = 0x0;

  1135.     retInfo.filename         = gNullCharPtr;

  1136.     retInfo.name             = gNullCharPtr;

  1137.     retInfo.iconName         = gNullCharPtr;

  1138.     retInfo.uniqueId         = 0;

  1139. 

  1140.     // cleanup

  1141.     if (retInfo.label != gNullCharPtr)

  1142.     {

  1143.         delete[] retInfo.label;

  1144.         retInfo.label = gNullCharPtr;

  1145.     }

  1146. 

  1147.     if (retInfo.maker != gNullCharPtr)

  1148.     {

  1149.         delete[] retInfo.maker;

  1150.         retInfo.maker = gNullCharPtr;

  1151.     }

  1152. 

  1153.     if (retInfo.copyright != gNullCharPtr)

  1154.     {

  1155.         delete[] retInfo.copyright;

  1156.         retInfo.copyright = gNullCharPtr;

  1157.     }

  1158. 

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

  1160. 

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

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

  1163. 

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

  1165. 

  1166.     char strBuf[STR_MAX+1];

  1167. 

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

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

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

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

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

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

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

  1175. 

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

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

  1178. 

  1179.     carla_zeroChars(strBuf, STR_MAX+1);

  1180.     plugin->getLabel(strBuf);

  1181.     retInfo.label = carla_strdup_safe(strBuf);

  1182. 

  1183.     carla_zeroChars(strBuf, STR_MAX+1);

  1184.     plugin->getMaker(strBuf);

  1185.     retInfo.maker = carla_strdup_safe(strBuf);

  1186. 

  1187.     carla_zeroChars(strBuf, STR_MAX+1);

  1188.     plugin->getCopyright(strBuf);

  1189.     retInfo.copyright = carla_strdup_safe(strBuf);

  1190. 

  1191.     checkStringPtr(retInfo.filename);

  1192.     checkStringPtr(retInfo.name);

  1193.     checkStringPtr(retInfo.iconName);

  1194.     checkStringPtr(retInfo.label);

  1195.     checkStringPtr(retInfo.maker);

  1196.     checkStringPtr(retInfo.copyright);

  1197. 

  1198.     return &retInfo;

  1199. }

  1200. 

  1201. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1202. {

  1203.     static CarlaPortCountInfo retInfo;

  1204.     carla_zeroStruct(retInfo);

  1205. 

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

  1207. 

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

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

  1210. 

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

  1212. 

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

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

  1215.     return &retInfo;

  1216. }

  1217. 

  1218. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1219. {

  1220.     static CarlaPortCountInfo retInfo;

  1221.     carla_zeroStruct(retInfo);

  1222. 

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

  1224. 

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

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

  1227. 

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

  1229. 

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

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

  1232.     return &retInfo;

  1233. }

  1234. 

  1235. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1236. {

  1237.     static CarlaPortCountInfo retInfo;

  1238.     carla_zeroStruct(retInfo);

  1239. 

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

  1241. 

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

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

  1244. 

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

  1246. 

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

  1248.     return &retInfo;

  1249. }

  1250. 

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

  1252. {

  1253.     static CarlaParameterInfo retInfo;

  1254. 

  1255.     // reset

  1256.     retInfo.scalePointCount = 0;

  1257. 

  1258.     // cleanup

  1259.     if (retInfo.name != gNullCharPtr)

  1260.     {

  1261.         delete[] retInfo.name;

  1262.         retInfo.name = gNullCharPtr;

  1263.     }

  1264. 

  1265.     if (retInfo.symbol != gNullCharPtr)

  1266.     {

  1267.         delete[] retInfo.symbol;

  1268.         retInfo.symbol = gNullCharPtr;

  1269.     }

  1270. 

  1271.     if (retInfo.unit != gNullCharPtr)

  1272.     {

  1273.         delete[] retInfo.unit;

  1274.         retInfo.unit = gNullCharPtr;

  1275.     }

  1276. 

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

  1278. 

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

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

  1281. 

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

  1283. 

  1284.     char strBuf[STR_MAX+1];

  1285. 

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

  1287. 

  1288.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1290.     retInfo.name = carla_strdup_safe(strBuf);

  1291. 

  1292.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1294.     retInfo.symbol = carla_strdup_safe(strBuf);

  1295. 

  1296.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1298.     retInfo.unit = carla_strdup_safe(strBuf);

  1299. 

  1300.     checkStringPtr(retInfo.name);

  1301.     checkStringPtr(retInfo.symbol);

  1302.     checkStringPtr(retInfo.unit);

  1303. 

  1304.     return &retInfo;

  1305. }

  1306. 

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

  1308. {

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

  1310. 

  1311.     static CarlaScalePointInfo retInfo;

  1312. 

  1313.     // reset

  1314.     retInfo.value = 0.0f;

  1315. 

  1316.     // cleanup

  1317.     if (retInfo.label != gNullCharPtr)

  1318.     {

  1319.         delete[] retInfo.label;

  1320.         retInfo.label = gNullCharPtr;

  1321.     }

  1322. 

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

  1324. 

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

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

  1327. 

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

  1329. 

  1330.     char strBuf[STR_MAX+1];

  1331. 

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

  1333. 

  1334.     carla_zeroChars(strBuf, STR_MAX+1);

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

  1336.     retInfo.label = carla_strdup_safe(strBuf);

  1337. 

  1338.     checkStringPtr(retInfo.label);

  1339. 

  1340.     return &retInfo;

  1341. }

  1342. 

  1343. // --------------------------------------------------------------------------------------------------------------------

  1344. 

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

  1346. {

  1347.     static ParameterData retParamData;

  1348. 

  1349.     // reset

  1350.     retParamData.type        = CB::PARAMETER_UNKNOWN;

  1351.     retParamData.hints       = 0x0;

  1352.     retParamData.index       = CB::PARAMETER_NULL;

  1353.     retParamData.rindex      = -1;

  1354.     retParamData.midiCC      = -1;

  1355.     retParamData.midiChannel = 0;

  1356. 

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

  1358. 

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

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

  1361. 

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

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

  1364. 

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

  1366.     retParamData.type        = pluginParamData.type;

  1367.     retParamData.hints       = pluginParamData.hints;

  1368.     retParamData.index       = pluginParamData.index;

  1369.     retParamData.rindex      = pluginParamData.rindex;

  1370.     retParamData.midiCC      = pluginParamData.midiCC;

  1371.     retParamData.midiChannel = pluginParamData.midiChannel;

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

  1373. }

  1374. 

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

  1376. {

  1377.     static ParameterRanges retParamRanges;

  1378. 

  1379.     // reset

  1380.     retParamRanges.def       = 0.0f;

  1381.     retParamRanges.min       = 0.0f;

  1382.     retParamRanges.max       = 1.0f;

  1383.     retParamRanges.step      = 0.01f;

  1384.     retParamRanges.stepSmall = 0.0001f;

  1385.     retParamRanges.stepLarge = 0.1f;

  1386. 

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

  1388. 

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

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

  1391. 

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

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

  1394. 

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

  1396.     retParamRanges.def       = pluginParamRanges.def;

  1397.     retParamRanges.min       = pluginParamRanges.min;

  1398.     retParamRanges.max       = pluginParamRanges.max;

  1399.     retParamRanges.step      = pluginParamRanges.step;

  1400.     retParamRanges.stepSmall = pluginParamRanges.stepSmall;

  1401.     retParamRanges.stepLarge = pluginParamRanges.stepLarge;

  1402.     return &pluginParamRanges;

  1403. }

  1404. 

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

  1406. {

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

  1408. 

  1409.     // reset

  1410.     retMidiProgData.bank    = 0;

  1411.     retMidiProgData.program = 0;

  1412. 

  1413.     if (retMidiProgData.name != gNullCharPtr)

  1414.     {

  1415.         delete[] retMidiProgData.name;

  1416.         retMidiProgData.name = gNullCharPtr;

  1417.     }

  1418. 

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

  1420. 

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

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

  1423. 

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

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

  1426. 

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

  1428.     retMidiProgData.bank    = pluginMidiProgData.bank;

  1429.     retMidiProgData.program = pluginMidiProgData.program;

  1430. 

  1431.     if (pluginMidiProgData.name != nullptr)

  1432.     {

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

  1434.         checkStringPtr(retMidiProgData.name);

  1435.     }

  1436.     else

  1437.     {

  1438.         retMidiProgData.name = gNullCharPtr;

  1439.     }

  1440. 

  1441.     return &retMidiProgData;

  1442. }

  1443. 

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

  1445. {

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

  1447. 

  1448.     // reset

  1449.     if (retCustomData.type != gNullCharPtr)

  1450.     {

  1451.         delete[] retCustomData.type;

  1452.         retCustomData.type = gNullCharPtr;

  1453.     }

  1454. 

  1455.     if (retCustomData.key != gNullCharPtr)

  1456.     {

  1457.         delete[] retCustomData.key;

  1458.         retCustomData.key = gNullCharPtr;

  1459.     }

  1460. 

  1461.     if (retCustomData.value != gNullCharPtr)

  1462.     {

  1463.         delete[] retCustomData.value;

  1464.         retCustomData.value = gNullCharPtr;

  1465.     }

  1466. 

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

  1468. 

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

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

  1471. 

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

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

  1474. 

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

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

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

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

  1479.     checkStringPtr(retCustomData.type);

  1480.     checkStringPtr(retCustomData.key);

  1481.     checkStringPtr(retCustomData.value);

  1482.     return &retCustomData;

  1483. }

  1484. 

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

  1486. {

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

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

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

  1490. 

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

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

  1493. 

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

  1495. 

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

  1497. 

  1498.     if (count == 0)

  1499.         return gNullCharPtr;

  1500. 

  1501.     static CarlaString customDataValue;

  1502. 

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

  1504.     {

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

  1506. 

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

  1508.             continue;

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

  1510.             continue;

  1511. 

  1512.         customDataValue = pluginCustomData.value;

  1513.         return customDataValue.buffer();

  1514.     }

  1515. 

  1516.     return gNullCharPtr;

  1517. }

  1518. 

  1519. const char* carla_get_chunk_data(uint pluginId)

  1520. {

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

  1522. 

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

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

  1525. 

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

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

  1528. 

  1529.     void* data = nullptr;

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

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

  1532. 

  1533.     static CarlaString chunkData;

  1534. 

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

  1536.     return chunkData.buffer();

  1537. }

  1538. 

  1539. // --------------------------------------------------------------------------------------------------------------------

  1540. 

  1541. uint32_t carla_get_parameter_count(uint pluginId)

  1542. {

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

  1544. 

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

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

  1547. 

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

  1549.     return plugin->getParameterCount();

  1550. }

  1551. 

  1552. uint32_t carla_get_program_count(uint pluginId)

  1553. {

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

  1555. 

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

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

  1558. 

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

  1560.     return plugin->getProgramCount();

  1561. }

  1562. 

  1563. uint32_t carla_get_midi_program_count(uint pluginId)

  1564. {

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

  1566. 

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

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

  1569. 

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

  1571.     return plugin->getMidiProgramCount();

  1572. }

  1573. 

  1574. uint32_t carla_get_custom_data_count(uint pluginId)

  1575. {

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

  1577. 

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

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

  1580. 

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

  1582.     return plugin->getCustomDataCount();

  1583. }

  1584. 

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

  1586. 

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

  1588. {

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

  1590. 

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

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

  1593. 

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

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

  1596. 

  1597.     static char textBuf[STR_MAX+1];

  1598.     carla_zeroChars(textBuf, STR_MAX+1);

  1599. 

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

  1601.     return textBuf;

  1602. }

  1603. 

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

  1605. {

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

  1607. 

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

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

  1610. 

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

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

  1613. 

  1614.     static char programName[STR_MAX+1];

  1615.     carla_zeroChars(programName, STR_MAX+1);

  1616. 

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

  1618.     return programName;

  1619. }

  1620. 

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

  1622. {

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

  1624. 

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

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

  1627. 

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

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

  1630. 

  1631.     static char midiProgramName[STR_MAX+1];

  1632.     carla_zeroChars(midiProgramName, STR_MAX+1);

  1633. 

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

  1635.     return midiProgramName;

  1636. }

  1637. 

  1638. const char* carla_get_real_plugin_name(uint pluginId)

  1639. {

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

  1641. 

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

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

  1644. 

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

  1646.     static char realPluginName[STR_MAX+1];

  1647.     carla_zeroChars(realPluginName, STR_MAX+1);

  1648. 

  1649.     plugin->getRealName(realPluginName);

  1650.     return realPluginName;

  1651. }

  1652. 

  1653. // --------------------------------------------------------------------------------------------------------------------

  1654. 

  1655. int32_t carla_get_current_program_index(uint pluginId)

  1656. {

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

  1658. 

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

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

  1661. 

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

  1663.     return plugin->getCurrentProgram();

  1664. }

  1665. 

  1666. int32_t carla_get_current_midi_program_index(uint pluginId)

  1667. {

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

  1669. 

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

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

  1672. 

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

  1674.     return plugin->getCurrentMidiProgram();

  1675. }

  1676. 

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

  1678. 

  1679. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1680. {

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

  1682. 

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

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

  1685. 

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

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

  1688. 

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

  1690. }

  1691. 

  1692. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1693. {

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

  1695. 

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

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

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

  1699. 

  1700.     return plugin->getParameterValue(parameterId);

  1701. }

  1702. 

  1703. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1704. {

  1705. #ifdef BUILD_BRIDGE

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

  1707. #else

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

  1709. #endif

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

  1711. 

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

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

  1714. 

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

  1716.     return plugin->getInternalParameterValue(parameterId);

  1717. }

  1718. 

  1719. // --------------------------------------------------------------------------------------------------------------------

  1720. 

  1721. float* carla_get_peak_values(uint pluginId)

  1722. {

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

  1724. 

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

  1726. }

  1727. 

  1728. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1729. {

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

  1731. 

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

  1733. }

  1734. 

  1735. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1736. {

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

  1738. 

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

  1740. }

  1741. 

  1742. // --------------------------------------------------------------------------------------------------------------------

  1743. 

  1744. CARLA_BACKEND_START_NAMESPACE

  1745. 

  1746. // defined in CarlaPluginLV2.cpp

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

  1748. 

  1749. CARLA_BACKEND_END_NAMESPACE

  1750. 

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

  1752. {

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

  1754. 

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

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

  1757. 

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

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

  1760. 

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

  1762. }

  1763. 

  1764. // --------------------------------------------------------------------------------------------------------------------

  1765. 

  1766. void carla_set_active(uint pluginId, bool onOff)

  1767. {

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

  1769. 

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

  1771.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1772. 

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

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

  1775. }

  1776. 

  1777. #ifndef BUILD_BRIDGE

  1778. void carla_set_drywet(uint pluginId, float value)

  1779. {

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

  1781. 

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

  1783.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1784. 

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

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

  1787. }

  1788. 

  1789. void carla_set_volume(uint pluginId, float value)

  1790. {

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

  1792. 

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

  1794.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1795. 

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

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

  1798. }

  1799. 

  1800. void carla_set_balance_left(uint pluginId, float value)

  1801. {

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

  1803. 

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

  1805.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1806. 

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

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

  1809. }

  1810. 

  1811. void carla_set_balance_right(uint pluginId, float value)

  1812. {

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

  1814. 

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

  1816.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1817. 

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

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

  1820. }

  1821. 

  1822. void carla_set_panning(uint pluginId, float value)

  1823. {

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

  1825. 

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

  1827.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1828. 

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

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

  1831. }

  1832. 

  1833. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1834. {

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

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

  1837. 

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

  1839.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1840. 

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

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

  1843. }

  1844. #endif

  1845. 

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

  1847. {

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

  1849. 

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

  1851.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1852. 

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

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

  1855. }

  1856. 

  1857. // --------------------------------------------------------------------------------------------------------------------

  1858. 

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

  1860. {

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

  1862. 

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

  1864.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1865. 

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

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

  1868. 

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

  1870. }

  1871. 

  1872. #ifndef BUILD_BRIDGE

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

  1874. {

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

  1876.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

  1877. 

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

  1879.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1880. 

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

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

  1883. 

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

  1885. }

  1886. 

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

  1888. {

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

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

  1891. 

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

  1893.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1894. 

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

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

  1897. 

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

  1899. }

  1900. #endif

  1901. 

  1902. // --------------------------------------------------------------------------------------------------------------------

  1903. 

  1904. void carla_set_program(uint pluginId, uint32_t programId)

  1905. {

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

  1907. 

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

  1909.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1910. 

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

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

  1913. 

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

  1915. }

  1916. 

  1917. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1918. {

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

  1920. 

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

  1922.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1923. 

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

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

  1926. 

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

  1928. }

  1929. 

  1930. // --------------------------------------------------------------------------------------------------------------------

  1931. 

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

  1933. {

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

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

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

  1937.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

  1938. 

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

  1940.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1941. 

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

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

  1944. }

  1945. 

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

  1947. {

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

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

  1950. 

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

  1952.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1953. 

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

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

  1956. 

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

  1958. #ifdef CARLA_PROPER_CPP11_SUPPORT

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

  1960. #else

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

  1962. #endif

  1963. }

  1964. 

  1965. // --------------------------------------------------------------------------------------------------------------------

  1966. 

  1967. void carla_prepare_for_save(uint pluginId)

  1968. {

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

  1970. 

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

  1972.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1973. 

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

  1975.     return plugin->prepareForSave();

  1976. }

  1977. 

  1978. void carla_reset_parameters(uint pluginId)

  1979. {

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

  1981. 

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

  1983.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1984. 

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

  1986.     return plugin->resetParameters();

  1987. }

  1988. 

  1989. void carla_randomize_parameters(uint pluginId)

  1990. {

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

  1992. 

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

  1994.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  1995. 

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

  1997.     return plugin->randomizeParameters();

  1998. }

  1999. 

  2000. #ifndef BUILD_BRIDGE

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

  2002. {

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

  2004. 

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

  2006.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2007. 

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

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

  2010. }

  2011. #endif

  2012. 

  2013. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2014. {

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

  2016. 

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

  2018.     CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);

  2019. 

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

  2021.     return plugin->showCustomUI(yesNo);

  2022. }

  2023. 

  2024. // --------------------------------------------------------------------------------------------------------------------

  2025. 

  2026. uint32_t carla_get_buffer_size()

  2027. {

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

  2029. 

  2030.     carla_debug("carla_get_buffer_size()");

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

  2032. }

  2033. 

  2034. double carla_get_sample_rate()

  2035. {

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

  2037. 

  2038.     carla_debug("carla_get_sample_rate()");

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

  2040. }

  2041. 

  2042. // --------------------------------------------------------------------------------------------------------------------

  2043. 

  2044. const char* carla_get_last_error()

  2045. {

  2046.     carla_debug("carla_get_last_error()");

  2047. 

  2048.     if (gStandalone.engine != nullptr)

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

  2050. 

  2051.     return gStandalone.lastError;

  2052. }

  2053. 

  2054. const char* carla_get_host_osc_url_tcp()

  2055. {

  2056.     carla_debug("carla_get_host_osc_url_tcp()");

  2057. 

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

  2059.     if (gStandalone.engine == nullptr)

  2060.     {

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

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

  2063.         return gNullCharPtr;

  2064.     }

  2065. 

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

  2067. 

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

  2069.         return path;

  2070. 

  2071.     static const char* const notAvailable = "OSC TCP port not available";

  2072.     return notAvailable;

  2073. #else

  2074.     return gNullCharPtr;

  2075. #endif

  2076. }

  2077. 

  2078. const char* carla_get_host_osc_url_udp()

  2079. {

  2080.     carla_debug("carla_get_host_osc_url_udp()");

  2081. 

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

  2083.     if (gStandalone.engine == nullptr)

  2084.     {

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

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

  2087.         return gNullCharPtr;

  2088.     }

  2089. 

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

  2091. 

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

  2093.         return path;

  2094. 

  2095.     static const char* const notAvailable = "OSC UDP port not available";

  2096.     return notAvailable;

  2097. #else

  2098.     return gNullCharPtr;

  2099. #endif

  2100. }

  2101. 

  2102. // --------------------------------------------------------------------------------------------------------------------

  2103. 

  2104. #define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone

  2105. #include "CarlaPluginUI.cpp"

  2106. #undef CARLA_PLUGIN_UI_CLASS_PREFIX

  2107. 

  2108. #include "CarlaDssiUtils.cpp"

  2109. #include "CarlaMacUtils.cpp"

  2110. #include "CarlaPatchbayUtils.cpp"

  2111. #include "CarlaPipeUtils.cpp"

  2112. #include "CarlaStateUtils.cpp"

  2113. 

  2114. // --------------------------------------------------------------------------------------------------------------------