falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2402 Commits
16 Branches
191MB
Tree: 2dc9ee8f83
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2dc9ee8f83'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2171 lines
77KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngine.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "CarlaOscUtils.hpp"

  30. 

  31. #include "juce_audio_formats.h"

  32. 

  33. #if defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)

  34. # include "juce_gui_basics.h"

  35. #else

  36. namespace juce {

  37. # include "juce_events/messages/juce_Initialisation.h"

  38. } // namespace juce

  39. #endif

  40. 

  41. namespace CB = CarlaBackend;

  42. using CB::EngineOptions;

  43. 

  44. // -------------------------------------------------------------------------------------------------------------------

  45. // Single, standalone engine

  46. 

  47. struct CarlaBackendStandalone {

  48.     CarlaEngine*       engine;

  49.     EngineCallbackFunc engineCallback;

  50.     void*              engineCallbackPtr;

  51.     EngineOptions      engineOptions;

  52. 

  53.     FileCallbackFunc fileCallback;

  54.     void*            fileCallbackPtr;

  55. 

  56.     CarlaString lastError;

  57. 

  58.     CarlaBackendStandalone()

  59.         : engine(nullptr),

  60.           engineCallback(nullptr),

  61.           engineCallbackPtr(nullptr),

  62.           engineOptions(),

  63.           fileCallback(nullptr),

  64.           fileCallbackPtr(nullptr),

  65.           lastError()

  66.     {

  67. #ifdef BUILD_BRIDGE

  68.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  69.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  70.         engineOptions.forceStereo         = false;

  71.         engineOptions.preferPluginBridges = false;

  72.         engineOptions.preferUiBridges     = false;

  73. 

  74.         using juce::File;

  75.         File binaryDir(File::getSpecialLocation(File::currentExecutableFile).getParentDirectory());

  76.         engineOptions.binaryDir   = carla_strdup_safe(binaryDir.getFullPathName().toRawUTF8());

  77.         engineOptions.resourceDir = carla_strdup_safe(binaryDir.getChildFile("resources").getFullPathName().toRawUTF8());

  78. #else

  79.         if (std::getenv("LADISH_APP_NAME") == nullptr && std::getenv("NSM_URL") == nullptr)

  80.             juce::Thread::setCurrentThreadName("Carla");

  81. #endif

  82.     }

  83. 

  84.     ~CarlaBackendStandalone()

  85.     {

  86.         CARLA_SAFE_ASSERT(engine == nullptr);

  87.     }

  88. 

  89.     CARLA_PREVENT_HEAP_ALLOCATION

  90.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  91. };

  92. 

  93. static CarlaBackendStandalone gStandalone;

  94. 

  95. // -------------------------------------------------------------------------------------------------------------------

  96. // NSM support

  97. 

  98. #define NSM_API_VERSION_MAJOR 1

  99. #define NSM_API_VERSION_MINOR 2

  100. 

  101. //#define NSM_CLIENT_FEATURES ":switch:optional-gui:"

  102. #define NSM_CLIENT_FEATURES ":switch:"

  103. 

  104. class CarlaNSM

  105. {

  106. public:

  107.     CarlaNSM() noexcept

  108.         : fOscServer(nullptr),

  109.           fClientId(),

  110.           fProjectPath(),

  111.           fHasBroadcast(false),

  112.           fHasShowHideUI(false) {}

  113. 

  114.     ~CarlaNSM()

  115.     {

  116.         if (fOscServer != nullptr)

  117.         {

  118.             lo_server_del_method(fOscServer, "/reply", "ssss");

  119.             lo_server_del_method(fOscServer, "/nsm/client/open", "sss");

  120.             lo_server_del_method(fOscServer, "/nsm/client/save", "");

  121.             //lo_server_del_method(fOscServer, "/nsm/client/show_optional_gui", "");

  122.             //lo_server_del_method(fOscServer, "/nsm/client/hide_optional_gui", "");

  123.             lo_server_free(fOscServer);

  124.             fOscServer = nullptr;

  125.         }

  126.     }

  127. 

  128.     void announce(const int pid, const char* const initName)

  129.     {

  130.         const char* const NSM_URL(std::getenv("NSM_URL"));

  131. 

  132.         if (NSM_URL == nullptr)

  133.             return;

  134. 

  135.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  136.         CARLA_SAFE_ASSERT_RETURN(addr != nullptr,);

  137. 

  138.         const int proto = lo_address_get_protocol(addr);

  139. 

  140.         if (fOscServer == nullptr)

  141.         {

  142.             // create new OSC server

  143.             fOscServer = lo_server_new_with_proto(nullptr, proto, _error_handler);

  144. 

  145.             // register message handlers and start OSC thread

  146.             lo_server_add_method(fOscServer, "/reply",           "ssss", _reply_handler, this);

  147.             lo_server_add_method(fOscServer, "/nsm/client/open", "sss",  _open_handler,  this);

  148.             lo_server_add_method(fOscServer, "/nsm/client/save", "",     _save_handler,  this);

  149.             //lo_server_add_method(fOscServer, "/nsm/client/show_optional_gui", "", _show_gui_handler, this);

  150.             //lo_server_add_method(fOscServer, "/nsm/client/hide_optional_gui", "", _hide_gui_handler, this);

  151.             // /nsm/client/session_is_loaded

  152.         }

  153. 

  154. #ifndef BUILD_ANSI_TEST

  155.         lo_send_from(addr, fOscServer, LO_TT_IMMEDIATE, "/nsm/server/announce", "sssiii",

  156.                      "Carla", NSM_CLIENT_FEATURES, initName, NSM_API_VERSION_MAJOR, NSM_API_VERSION_MINOR, pid);

  157. #endif

  158. 

  159.         lo_address_free(addr);

  160.     }

  161. 

  162.     void idle() noexcept

  163.     {

  164.         if (fOscServer == nullptr)

  165.             return;

  166. 

  167.         for (;;)

  168.         {

  169.             try {

  170.                 if (lo_server_recv_noblock(fOscServer, 0) == 0)

  171.                     break;

  172.             } CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  173.         }

  174.     }

  175. 

  176. protected:

  177.     int handleReply(const char* const path, const char* const types, lo_arg** const argv, const int argc, const lo_message msg)

  178.     {

  179.         carla_debug("CarlaNSM::handleReply(%s, %i, %p, %s, %p)", path, argc, argv, types, msg);

  180. 

  181.         const char* const method   = &argv[0]->s;

  182.         const char* const message  = &argv[1]->s;

  183.         const char* const smName   = &argv[2]->s;

  184.         const char* const features = &argv[3]->s;

  185. 

  186.         CARLA_SAFE_ASSERT_RETURN(std::strcmp(method, "/nsm/server/announce") == 0, 0);

  187. 

  188.         fHasBroadcast  = std::strstr(features, ":broadcast:") != nullptr;

  189.         fHasShowHideUI = std::strstr(features, ":optional-gui:") != nullptr;

  190. 

  191.         carla_stdout("'%s' started: %s", smName, message);

  192. 

  193.         // TODO: send callback, disable open+save etc

  194. 

  195.         return 0;

  196. 

  197. #ifndef DEBUG

  198.         // unused

  199.         (void)path; (void)types; (void)argc; (void)msg;

  200. #endif

  201.     }

  202. 

  203.     int handleOpen(const char* const path, const char* const types, lo_arg** const argv, const int argc, const lo_message msg)

  204.     {

  205.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 0);

  206.         carla_debug("CarlaNSM::handleOpen(\"%s\", \"%s\", %p, %i, %p)", path, types, argv, argc, msg);

  207. 

  208.         const char* const projectPath = &argv[0]->s;

  209.         //const char* const displayName = &argv[1]->s;

  210.         const char* const clientId    = &argv[2]->s;

  211. 

  212.         if (! carla_is_engine_running())

  213.         {

  214.             gStandalone.engineOptions.processMode   = CB::ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS;

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

  216. 

  217.             carla_engine_init("JACK", clientId);

  218.         }

  219.         else

  220.         {

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

  222. 

  223.             for (uint i=0, count=gStandalone.engine->getCurrentPluginCount(); i < count; ++i)

  224.                 gStandalone.engine->removePlugin(i);

  225.         }

  226. 

  227.         fClientId = clientId;

  228. 

  229.         fProjectPath  = projectPath;

  230.         fProjectPath += ".carxp";

  231. 

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

  233. 

  234.         if (juce::File(fProjectPath.buffer()).existsAsFile())

  235.             gStandalone.engine->loadProject(fProjectPath);

  236. 

  237. #ifndef BUILD_ANSI_TEST

  238.         lo_send_from(lo_message_get_source(msg), fOscServer, LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/open", "OK");

  239. #endif

  240. 

  241. #if 0

  242.         if (fHasBroadcast)

  243.         {

  244.             char* const url = lo_server_get_url(fOscServer);

  245. 

  246.             lo_send(lo_message_get_source(msg), "/nsm/server/broadcast", "sssss",

  247.                             "/non/hello", url, "Carla", CARLA_VERSION_STRING, clientId);

  248. 

  249.             //lo_send_from(lo_message_get_source(msg), fOscServer, LO_TT_IMMEDIATE, "/nsm/server/broadcast", "sssss"

  250.             //             "/non/hello", url, "Carla", CARLA_VERSION_STRING, clientId);

  251. 

  252.             lo_send(lo_message_get_source(msg), "/signal/created", "ssfff", "/path/somewhere", true ? "in" : "out", 0.0f, 1.0f, 0.5f);

  253. 

  254.             std::free(url);

  255. 

  256.             carla_stdout("Broadcast sent!");

  257.         }

  258.         else

  259.             carla_stdout("Broadcast NOT NOT NOT sent!");

  260. #endif

  261. 

  262.         return 0;

  263. 

  264. #ifndef DEBUG

  265.         // unused

  266.         (void)path; (void)types; (void)argc; (void)msg;

  267. #endif

  268.     }

  269. 

  270.     int handleSave(const char* const path, const char* const types, lo_arg** const argv, const int argc, const lo_message msg)

  271.     {

  272.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 0);

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

  274.         CARLA_SAFE_ASSERT_RETURN(fProjectPath.isNotEmpty(), 0);

  275.         carla_debug("CarlaNSM::handleSave(\"%s\", \"%s\", %p, %i, %p)", path, types, argv, argc, msg);

  276. 

  277.         gStandalone.engine->saveProject(fProjectPath);

  278. 

  279. #ifndef BUILD_ANSI_TEST

  280.         lo_send_from(lo_message_get_source(msg), fOscServer, LO_TT_IMMEDIATE, "/reply", "ss", "/nsm/client/save", "OK");

  281. #endif

  282. 

  283.         return 0;

  284. 

  285. #ifndef DEBUG

  286.         // unused

  287.         (void)path; (void)types; (void)argv; (void)argc; (void)msg;

  288. #endif

  289.     }

  290. 

  291. #if 0

  292.     int handleShowHideGui(const lo_message msg, const bool show)

  293.     {

  294.         CARLA_SAFE_ASSERT_RETURN(fOscServer != nullptr, 0);

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

  296.         //CARLA_SAFE_ASSERT_RETURN(gStandalone.frontendWinId != 0, 0);

  297.         carla_debug("CarlaNSM::handleShowHideGui(%s)", bool2str(show));

  298. 

  299. #ifndef BUILD_ANSI_TEST

  300.         lo_send_from(lo_message_get_source(msg), fOscServer, LO_TT_IMMEDIATE, show ? "/nsm/client/gui_is_shown" : "/nsm/client/gui_is_hidden", "");

  301. #endif

  302. 

  303.         return 0;

  304.     }

  305. #endif

  306. 

  307. private:

  308.     lo_server fOscServer;

  309. 

  310.     CarlaString fClientId;

  311.     CarlaString fProjectPath;

  312. 

  313.     bool fHasBroadcast;

  314.     bool fHasShowHideUI;

  315. 

  316.     #define handlePtr ((CarlaNSM*)data)

  317. 

  318.     static void _error_handler(int num, const char* msg, const char* path)

  319.     {

  320.         carla_stderr2("CarlaNSM::_error_handler(%i, \"%s\", \"%s\")", num, msg, path);

  321.     }

  322. 

  323.     static int _reply_handler(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)

  324.     {

  325.         return handlePtr->handleReply(path, types, argv, argc, msg);

  326.     }

  327. 

  328.     static int _open_handler(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)

  329.     {

  330.         return handlePtr->handleOpen(path, types, argv, argc, msg);

  331.     }

  332. 

  333.     static int _save_handler(const char* path, const char* types, lo_arg** argv, int argc, lo_message msg, void* data)

  334.     {

  335.         return handlePtr->handleSave(path, types, argv, argc, msg);

  336.     }

  337. 

  338. #if 0

  339.     static int _show_gui_handler(const char*, const char*, lo_arg**, int, lo_message, void* data)

  340.     {

  341.         return handlePtr->handleShowHideGui(true);

  342.     }

  343. 

  344.     static int _hide_gui_handler(const char*, const char*, lo_arg**, int, lo_message, void* data)

  345.     {

  346.         return handlePtr->handleShowHideGui(false);

  347.     }

  348. #endif

  349. 

  350.     #undef handlePtr

  351. 

  352.     CARLA_PREVENT_HEAP_ALLOCATION

  353.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  354. };

  355. 

  356. static CarlaNSM gNSM;

  357. 

  358. // -------------------------------------------------------------------------------------------------------------------

  359. // API

  360. 

  361. #include "CarlaHostCommon.cpp"

  362. 

  363. // -------------------------------------------------------------------------------------------------------------------

  364. 

  365. uint carla_get_engine_driver_count()

  366. {

  367.     carla_debug("carla_get_engine_driver_count()");

  368. 

  369.     return CarlaEngine::getDriverCount();

  370. }

  371. 

  372. const char* carla_get_engine_driver_name(uint index)

  373. {

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

  375. 

  376.     return CarlaEngine::getDriverName(index);

  377. }

  378. 

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

  380. {

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

  382. 

  383.     return CarlaEngine::getDriverDeviceNames(index);

  384. }

  385. 

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

  387. {

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

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

  390. 

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

  392.     {

  393.         static EngineDriverDeviceInfo devInfo;

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

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

  396. 

  397.         devInfo.hints       = ret->hints;

  398.         devInfo.bufferSizes = (ret->bufferSizes != nullptr) ? ret->bufferSizes : nullBufferSizes;

  399.         devInfo.sampleRates = (ret->sampleRates != nullptr) ? ret->sampleRates : nullSampleRates;

  400.         return &devInfo;

  401.     }

  402. 

  403.     return nullptr;

  404. }

  405. 

  406. // -------------------------------------------------------------------------------------------------------------------

  407. 

  408. const CarlaEngine* carla_get_engine()

  409. {

  410.     carla_debug("carla_get_engine()");

  411. 

  412.     return gStandalone.engine;

  413. }

  414. 

  415. // -------------------------------------------------------------------------------------------------------------------

  416. 

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

  418. {

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

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

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

  422. 

  423.     if (gStandalone.engine != nullptr)

  424.     {

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

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

  427.         return false;

  428.     }

  429. 

  430. #ifdef CARLA_OS_WIN

  431.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  432. #endif

  433. 

  434.     // TODO: make this an option, put somewhere else

  435.     if (std::getenv("WINE_RT") == nullptr)

  436.     {

  437.         carla_setenv("WINE_RT", "15");

  438.         carla_setenv("WINE_SVR_RT", "10");

  439.     }

  440. 

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

  442. 

  443.     if (gStandalone.engine == nullptr)

  444.     {

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

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

  447.         return false;

  448.     }

  449. 

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

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

  452. 

  453. #ifdef BUILD_BRIDGE

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

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

  456. #else

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

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

  459. #endif

  460. 

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

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

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

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

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

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

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

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

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

  470. 

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

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

  473. 

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

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

  476. 

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

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

  479. 

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

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

  482. 

  483.     if (gStandalone.engineOptions.pathVST != nullptr)

  484.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,    CB::PLUGIN_VST, gStandalone.engineOptions.pathVST);

  485. 

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

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

  488. 

  489.     if (gStandalone.engineOptions.pathAU != nullptr)

  490.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH,    CB::PLUGIN_AU, gStandalone.engineOptions.pathAU);

  491. 

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

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

  494. 

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

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

  497. 

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

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

  500. 

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

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

  503. 

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

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

  506. 

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

  508. 

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

  510.     {

  511.         char strBuf[STR_MAX+1];

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

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

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

  515.     }

  516.     else

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

  518. 

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

  520.     {

  521. #ifndef BUILD_BRIDGE

  522.         juce::initialiseJuce_GUI();

  523. #endif

  524.         gStandalone.lastError = "No error";

  525.         return true;

  526.     }

  527.     else

  528.     {

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

  530.         delete gStandalone.engine;

  531.         gStandalone.engine = nullptr;

  532.         return false;

  533.     }

  534. }

  535. 

  536. #ifdef BUILD_BRIDGE

  537. bool carla_engine_init_bridge(const char audioBaseName[6+1], const char rtBaseName[6+1], const char nonRtBaseName[6+1], const char* clientName)

  538. {

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

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

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

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

  543.     carla_debug("carla_engine_init_bridge(\"%s\", \"%s\", \"%s\", \"%s\")", audioBaseName, rtBaseName, nonRtBaseName, clientName);

  544. 

  545.     if (gStandalone.engine != nullptr)

  546.     {

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

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

  549.         return false;

  550.     }

  551. 

  552.     gStandalone.engine = CarlaEngine::newBridge(audioBaseName, rtBaseName, nonRtBaseName);

  553. 

  554.     if (gStandalone.engine == nullptr)

  555.     {

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

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

  558.         return false;

  559.     }

  560. 

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

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

  563. 

  564.     // forced options for bridge mode

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

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

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

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

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

  570. 

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

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

  573. 

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

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

  576. 

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

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

  579. 

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

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

  582. 

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

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

  585. 

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

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

  588. 

  589.     if (const char* const pathVST = std::getenv("ENGINE_OPTION_PLUGIN_PATH_VST"))

  590.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_VST, pathVST);

  591. 

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

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

  594. 

  595.     if (const char* const pathAU = std::getenv("ENGINE_OPTION_PLUGIN_PATH_AU"))

  596.         gStandalone.engine->setOption(CB::ENGINE_OPTION_PLUGIN_PATH, CB::PLUGIN_AU, pathAU);

  597. 

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

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

  600. 

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

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

  603. 

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

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

  606. 

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

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

  609. 

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

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

  612. 

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

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

  615. 

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

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

  618. 

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

  620.     {

  621.         gStandalone.lastError = "No error";

  622.         return true;

  623.     }

  624.     else

  625.     {

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

  627.         delete gStandalone.engine;

  628.         gStandalone.engine = nullptr;

  629.         return false;

  630.     }

  631. }

  632. #endif

  633. 

  634. bool carla_engine_close()

  635. {

  636.     carla_debug("carla_engine_close()");

  637. 

  638.     if (gStandalone.engine == nullptr)

  639.     {

  640.         carla_stderr2("Engine is not running");

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

  642.         return false;

  643.     }

  644. 

  645.     gStandalone.engine->setAboutToClose();

  646.     gStandalone.engine->removeAllPlugins();

  647. 

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

  649. 

  650.     if (! closed)

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

  652. 

  653. #ifndef BUILD_BRIDGE

  654.     juce::shutdownJuce_GUI();

  655. #endif

  656.     delete gStandalone.engine;

  657.     gStandalone.engine = nullptr;

  658. 

  659.     return closed;

  660. }

  661. 

  662. void carla_engine_idle()

  663. {

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

  665. 

  666.     gNSM.idle();

  667.     gStandalone.engine->idle();

  668. }

  669. 

  670. bool carla_is_engine_running()

  671. {

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

  673. }

  674. 

  675. void carla_set_engine_about_to_close()

  676. {

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

  678.     carla_debug("carla_set_engine_about_to_close()");

  679. 

  680.     gStandalone.engine->setAboutToClose();

  681. }

  682. 

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

  684. {

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

  686. 

  687.     gStandalone.engineCallback    = func;

  688.     gStandalone.engineCallbackPtr = ptr;

  689. 

  690.     if (gStandalone.engine != nullptr)

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

  692. 

  693. //#ifdef WANT_LOGS

  694. //    gLogThread.setCallback(func, ptr);

  695. //#endif

  696. }

  697. 

  698. #ifndef BUILD_BRIDGE

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

  700. {

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

  702. 

  703.     switch (option)

  704.     {

  705.     case CB::ENGINE_OPTION_DEBUG:

  706.         break;

  707. 

  708.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  711.         break;

  712. 

  713.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

  714.         CARLA_SAFE_ASSERT_RETURN(value >= CB::ENGINE_TRANSPORT_MODE_INTERNAL && value < CB::ENGINE_TRANSPORT_MODE_BRIDGE,);

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

  716.         break;

  717. 

  718.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  721.         break;

  722. 

  723.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  726.         break;

  727. 

  728.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  731.         break;

  732. 

  733.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  736.         break;

  737. 

  738.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  739.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  741.         break;

  742. 

  743.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  744.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  746.         break;

  747. 

  748.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  751.         break;

  752. 

  753.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  754.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  756.         break;

  757. 

  758.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  759.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  761.         break;

  762. 

  763.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  764.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  765. 

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

  767.             delete[] gStandalone.engineOptions.audioDevice;

  768. 

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

  770.         break;

  771. 

  772.     case CB:: ENGINE_OPTION_NSM_INIT:

  773.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  775.         gNSM.announce(value, valueStr);

  776.         break;

  777. 

  778.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  781.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  782. 

  783.         switch (value)

  784.         {

  785.         case CB::PLUGIN_LADSPA:

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

  787.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  789.             break;

  790.         case CB::PLUGIN_DSSI:

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

  792.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  794.             break;

  795.         case CB::PLUGIN_LV2:

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

  797.                 delete[] gStandalone.engineOptions.pathLV2;

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

  799.             break;

  800.         case CB::PLUGIN_VST:

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

  802.                 delete[] gStandalone.engineOptions.pathVST;

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

  804.             break;

  805.         case CB::PLUGIN_VST3:

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

  807.                 delete[] gStandalone.engineOptions.pathVST3;

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

  809.             break;

  810.         case CB::PLUGIN_AU:

  811.             if (gStandalone.engineOptions.pathAU != nullptr)

  812.                 delete[] gStandalone.engineOptions.pathAU;

  813.             gStandalone.engineOptions.pathAU = carla_strdup_safe(valueStr);

  814.             break;

  815.         case CB::PLUGIN_GIG:

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

  817.                 delete[] gStandalone.engineOptions.pathGIG;

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

  819.             break;

  820.         case CB::PLUGIN_SF2:

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

  822.                 delete[] gStandalone.engineOptions.pathSF2;

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

  824.             break;

  825.         case CB::PLUGIN_SFZ:

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

  827.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  829.             break;

  830.         }

  831.         break;

  832. 

  833.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  835. 

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

  837.             delete[] gStandalone.engineOptions.binaryDir;

  838. 

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

  840.         break;

  841. 

  842.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  844. 

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

  846.             delete[] gStandalone.engineOptions.resourceDir;

  847. 

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

  849.         break;

  850. 

  851.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  854.         break;

  855. 

  856.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  859.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  861.         break;

  862.     }

  863. 

  864.     if (gStandalone.engine != nullptr)

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

  866. }

  867. #endif

  868. 

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

  870. {

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

  872. 

  873.     gStandalone.fileCallback    = func;

  874.     gStandalone.fileCallbackPtr = ptr;

  875. 

  876.     if (gStandalone.engine != nullptr)

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

  878. }

  879. 

  880. // -------------------------------------------------------------------------------------------------------------------

  881. 

  882. bool carla_load_file(const char* filename)

  883. {

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

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

  886. 

  887.     if (gStandalone.engine != nullptr)

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

  889. 

  890.     carla_stderr2("Engine is not running");

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

  892.     return false;

  893. }

  894. 

  895. bool carla_load_project(const char* filename)

  896. {

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

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

  899. 

  900.     if (gStandalone.engine != nullptr)

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

  902. 

  903.     carla_stderr2("Engine is not running");

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

  905.     return false;

  906. }

  907. 

  908. bool carla_save_project(const char* filename)

  909. {

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

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

  912. 

  913.     if (gStandalone.engine != nullptr)

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

  915. 

  916.     carla_stderr2("Engine was never initiated");

  917.     gStandalone.lastError = "Engine was never initiated";

  918.     return false;

  919. }

  920. 

  921. #ifndef BUILD_BRIDGE

  922. // -------------------------------------------------------------------------------------------------------------------

  923. 

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

  925. {

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

  927. 

  928.     if (gStandalone.engine != nullptr)

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

  930. 

  931.     carla_stderr2("Engine is not running");

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

  933.     return false;

  934. }

  935. 

  936. bool carla_patchbay_disconnect(uint connectionId)

  937. {

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

  939. 

  940.     if (gStandalone.engine != nullptr)

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

  942. 

  943.     carla_stderr2("Engine is not running");

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

  945.     return false;

  946. }

  947. 

  948. bool carla_patchbay_refresh(bool external)

  949. {

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

  951. 

  952.     if (gStandalone.engine != nullptr)

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

  954. 

  955.     carla_stderr2("Engine is not running");

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

  957.     return false;

  958. }

  959. 

  960. // -------------------------------------------------------------------------------------------------------------------

  961. 

  962. void carla_transport_play()

  963. {

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

  965.     carla_debug("carla_transport_play()");

  966. 

  967.     gStandalone.engine->transportPlay();

  968. }

  969. 

  970. void carla_transport_pause()

  971. {

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

  973.     carla_debug("carla_transport_pause()");

  974. 

  975.     gStandalone.engine->transportPause();

  976. }

  977. 

  978. void carla_transport_relocate(uint64_t frame)

  979. {

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

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

  982. 

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

  984. }

  985. 

  986. uint64_t carla_get_current_transport_frame()

  987. {

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

  989. 

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

  991.     return timeInfo.frame;

  992. }

  993. 

  994. const CarlaTransportInfo* carla_get_transport_info()

  995. {

  996.     static CarlaTransportInfo retInfo;

  997. 

  998.     // reset

  999.     retInfo.playing = false;

  1000.     retInfo.frame   = 0;

  1001.     retInfo.bar     = 0;

  1002.     retInfo.beat    = 0;

  1003.     retInfo.tick    = 0;

  1004.     retInfo.bpm     = 0.0;

  1005. 

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

  1007. 

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

  1009. 

  1010.     retInfo.playing = timeInfo.playing;

  1011.     retInfo.frame   = timeInfo.frame;

  1012. 

  1013.     if (timeInfo.valid & CB::EngineTimeInfo::kValidBBT)

  1014.     {

  1015.         retInfo.bar  = timeInfo.bbt.bar;

  1016.         retInfo.beat = timeInfo.bbt.beat;

  1017.         retInfo.tick = timeInfo.bbt.tick;

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

  1019.     }

  1020. 

  1021.     return &retInfo;

  1022. }

  1023. #endif

  1024. 

  1025. // -------------------------------------------------------------------------------------------------------------------

  1026. 

  1027. uint32_t carla_get_current_plugin_count()

  1028. {

  1029.     if (gStandalone.engine != nullptr)

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

  1031. 

  1032.     return 0;

  1033. }

  1034. 

  1035. uint32_t carla_get_max_plugin_number()

  1036. {

  1037.     if (gStandalone.engine != nullptr)

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

  1039. 

  1040.     return 0;

  1041. }

  1042. 

  1043. // -------------------------------------------------------------------------------------------------------------------

  1044. 

  1045. bool carla_add_plugin(BinaryType btype, PluginType ptype, const char* filename, const char* name, const char* label, int64_t uniqueId, const void* extraPtr)

  1046. {

  1047.     CARLA_SAFE_ASSERT_RETURN(label != nullptr /*&& label[0] != '\0'*/, false);

  1048.     carla_debug("carla_add_plugin(%i:%s, %i:%s, \"%s\", \"%s\", \"%s\", " P_INT64 ", %p)", btype, CB::BinaryType2Str(btype), ptype, CB::PluginType2Str(ptype), filename, name, label, uniqueId, extraPtr);

  1049. 

  1050.     if (gStandalone.engine != nullptr)

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

  1052. 

  1053.     carla_stderr2("Engine is not running");

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

  1055.     return false;

  1056. }

  1057. 

  1058. bool carla_remove_plugin(uint pluginId)

  1059. {

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

  1061. 

  1062.     if (gStandalone.engine != nullptr)

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

  1064. 

  1065.     carla_stderr2("Engine is not running");

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

  1067.     return false;

  1068. }

  1069. 

  1070. bool carla_remove_all_plugins()

  1071. {

  1072.     carla_debug("carla_remove_all_plugins()");

  1073. 

  1074.     if (gStandalone.engine != nullptr)

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

  1076. 

  1077.     carla_stderr2("Engine is not running");

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

  1079.     return false;

  1080. }

  1081. 

  1082. #ifndef BUILD_BRIDGE

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

  1084. {

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

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

  1087. 

  1088.     if (gStandalone.engine != nullptr)

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

  1090. 

  1091.     carla_stderr2("Engine is not running");

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

  1093.     return nullptr;

  1094. }

  1095. 

  1096. bool carla_clone_plugin(uint pluginId)

  1097. {

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

  1099. 

  1100.     if (gStandalone.engine != nullptr)

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

  1102. 

  1103.     carla_stderr2("Engine is not running");

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

  1105.     return false;

  1106. }

  1107. 

  1108. bool carla_replace_plugin(uint pluginId)

  1109. {

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

  1111. 

  1112.     if (gStandalone.engine != nullptr)

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

  1114. 

  1115.     carla_stderr2("Engine is not running");

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

  1117.     return false;

  1118. }

  1119. 

  1120. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1121. {

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

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

  1124. 

  1125.     if (gStandalone.engine != nullptr)

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

  1127. 

  1128.     carla_stderr2("Engine is not running");

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

  1130.     return false;

  1131. }

  1132. #endif

  1133. 

  1134. // -------------------------------------------------------------------------------------------------------------------

  1135. 

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

  1137. {

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

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

  1140. 

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

  1142.     {

  1143.         carla_stderr2("Engine is not running");

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

  1145.         return false;

  1146.     }

  1147. 

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

  1149.         return plugin->loadStateFromFile(filename);

  1150. 

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

  1152.     return false;

  1153. }

  1154. 

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

  1156. {

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

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

  1159. 

  1160.     if (gStandalone.engine == nullptr)

  1161.     {

  1162.         carla_stderr2("Engine is not running");

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

  1164.         return false;

  1165.     }

  1166. 

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

  1168. 

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

  1170.         return plugin->saveStateToFile(filename);

  1171. 

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

  1173.     return false;

  1174. }

  1175. 

  1176. // -------------------------------------------------------------------------------------------------------------------

  1177. 

  1178. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1179. {

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

  1181. 

  1182.     static CarlaPluginInfo info;

  1183. 

  1184.     // reset

  1185.     info.type             = CB::PLUGIN_NONE;

  1186.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1187.     info.hints            = 0x0;

  1188.     info.optionsAvailable = 0x0;

  1189.     info.optionsEnabled   = 0x0;

  1190.     info.filename         = gNullCharPtr;

  1191.     info.name             = gNullCharPtr;

  1192.     info.iconName         = gNullCharPtr;

  1193.     info.uniqueId         = 0;

  1194. 

  1195.     // cleanup

  1196.     if (info.label != gNullCharPtr)

  1197.     {

  1198.         delete[] info.label;

  1199.         info.label = gNullCharPtr;

  1200.     }

  1201. 

  1202.     if (info.maker != gNullCharPtr)

  1203.     {

  1204.         delete[] info.maker;

  1205.         info.maker = gNullCharPtr;

  1206.     }

  1207. 

  1208.     if (info.copyright != gNullCharPtr)

  1209.     {

  1210.         delete[] info.copyright;

  1211.         info.copyright = gNullCharPtr;

  1212.     }

  1213. 

  1214.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1215. 

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

  1217.     {

  1218.         char strBufLabel[STR_MAX+1];

  1219.         char strBufMaker[STR_MAX+1];

  1220.         char strBufCopyright[STR_MAX+1];

  1221. 

  1222.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1223.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1224.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1225. 

  1226.         info.type     = plugin->getType();

  1227.         info.category = plugin->getCategory();

  1228.         info.hints    = plugin->getHints();

  1229.         info.filename = plugin->getFilename();

  1230.         info.name     = plugin->getName();

  1231.         info.iconName = plugin->getIconName();

  1232.         info.uniqueId = plugin->getUniqueId();

  1233. 

  1234.         info.optionsAvailable = plugin->getOptionsAvailable();

  1235.         info.optionsEnabled   = plugin->getOptionsEnabled();

  1236. 

  1237.         plugin->getLabel(strBufLabel);

  1238.         info.label = carla_strdup_safe(strBufLabel);

  1239. 

  1240.         plugin->getMaker(strBufMaker);

  1241.         info.maker = carla_strdup_safe(strBufMaker);

  1242. 

  1243.         plugin->getCopyright(strBufCopyright);

  1244.         info.copyright = carla_strdup_safe(strBufCopyright);

  1245. 

  1246.         checkStringPtr(info.filename);

  1247.         checkStringPtr(info.name);

  1248.         checkStringPtr(info.iconName);

  1249.         checkStringPtr(info.label);

  1250.         checkStringPtr(info.maker);

  1251.         checkStringPtr(info.copyright);

  1252. 

  1253.         return &info;

  1254.     }

  1255. 

  1256.     carla_stderr2("carla_get_plugin_info(%i) - could not find plugin", pluginId);

  1257.     return &info;

  1258. }

  1259. 

  1260. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1261. {

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

  1263. 

  1264.     static CarlaPortCountInfo info;

  1265. 

  1266.     // reset

  1267.     info.ins   = 0;

  1268.     info.outs  = 0;

  1269. 

  1270.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1271. 

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

  1273.     {

  1274.         info.ins   = plugin->getAudioInCount();

  1275.         info.outs  = plugin->getAudioOutCount();

  1276.         return &info;

  1277.     }

  1278. 

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

  1280.     return &info;

  1281. }

  1282. 

  1283. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1284. {

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

  1286. 

  1287.     static CarlaPortCountInfo info;

  1288. 

  1289.     // reset

  1290.     info.ins   = 0;

  1291.     info.outs  = 0;

  1292. 

  1293.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1294. 

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

  1296.     {

  1297.         info.ins   = plugin->getMidiInCount();

  1298.         info.outs  = plugin->getMidiOutCount();

  1299.         return &info;

  1300.     }

  1301. 

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

  1303.     return &info;

  1304. }

  1305. 

  1306. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1307. {

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

  1309. 

  1310.     static CarlaPortCountInfo info;

  1311. 

  1312.     // reset

  1313.     info.ins   = 0;

  1314.     info.outs  = 0;

  1315. 

  1316.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1317. 

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

  1319.     {

  1320.         plugin->getParameterCountInfo(info.ins, info.outs);

  1321.         return &info;

  1322.     }

  1323. 

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

  1325.     return &info;

  1326. }

  1327. 

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

  1329. {

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

  1331. 

  1332.     static CarlaParameterInfo info;

  1333. 

  1334.     // reset

  1335.     info.scalePointCount = 0;

  1336. 

  1337.     // cleanup

  1338.     if (info.name != gNullCharPtr)

  1339.     {

  1340.         delete[] info.name;

  1341.         info.name = gNullCharPtr;

  1342.     }

  1343. 

  1344.     if (info.symbol != gNullCharPtr)

  1345.     {

  1346.         delete[] info.symbol;

  1347.         info.symbol = gNullCharPtr;

  1348.     }

  1349. 

  1350.     if (info.unit != gNullCharPtr)

  1351.     {

  1352.         delete[] info.unit;

  1353.         info.unit = gNullCharPtr;

  1354.     }

  1355. 

  1356.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1357. 

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

  1359.     {

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

  1361.         {

  1362.             char strBufName[STR_MAX+1];

  1363.             char strBufSymbol[STR_MAX+1];

  1364.             char strBufUnit[STR_MAX+1];

  1365. 

  1366.             carla_zeroChar(strBufName, STR_MAX+1);

  1367.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1368.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1369. 

  1370.             info.scalePointCount = plugin->getParameterScalePointCount(parameterId);

  1371. 

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

  1373.             info.name = carla_strdup_safe(strBufName);

  1374. 

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

  1376.             info.symbol = carla_strdup_safe(strBufSymbol);

  1377. 

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

  1379.             info.unit = carla_strdup_safe(strBufUnit);

  1380. 

  1381.             checkStringPtr(info.name);

  1382.             checkStringPtr(info.symbol);

  1383.             checkStringPtr(info.unit);

  1384.         }

  1385.         else

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

  1387. 

  1388.         return &info;

  1389.     }

  1390. 

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

  1392.     return &info;

  1393. }

  1394. 

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

  1396. {

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

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

  1399. 

  1400.     static CarlaScalePointInfo info;

  1401. 

  1402.     // reset

  1403.     info.value = 0.0f;

  1404. 

  1405.     // cleanup

  1406.     if (info.label != gNullCharPtr)

  1407.     {

  1408.         delete[] info.label;

  1409.         info.label = gNullCharPtr;

  1410.     }

  1411. 

  1412.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &info);

  1413. 

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

  1415.     {

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

  1417.         {

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

  1419.             {

  1420.                 char strBufLabel[STR_MAX+1];

  1421.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1422. 

  1423.                 info.value = plugin->getParameterScalePointValue(parameterId, scalePointId);

  1424. 

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

  1426.                 info.label = carla_strdup_safe(strBufLabel);

  1427.                 checkStringPtr(info.label);

  1428.             }

  1429.             else

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

  1431.         }

  1432.         else

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

  1434. 

  1435.         return &info;

  1436.     }

  1437. 

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

  1439.     return &info;

  1440. }

  1441. 

  1442. // -------------------------------------------------------------------------------------------------------------------

  1443. 

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

  1445. {

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

  1447. 

  1448.     static const ParameterData fallbackParameterData = { CB::PARAMETER_UNKNOWN, 0x0, CB::PARAMETER_NULL, -1, -1, 0 };

  1449. 

  1450.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &fallbackParameterData);

  1451. 

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

  1453.     {

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

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

  1456. 

  1457.         carla_stderr2("carla_get_parameter_data(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1458.         return &fallbackParameterData;

  1459.     }

  1460. 

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

  1462.     return &fallbackParameterData;

  1463. }

  1464. 

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

  1466. {

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

  1468. 

  1469.     static const ParameterRanges fallbackParamRanges = { 0.0f, 0.0f, 1.0f, 0.01f, 0.0001f, 0.1f };

  1470. 

  1471.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &fallbackParamRanges);

  1472. 

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

  1474.     {

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

  1476.             return &plugin->getParameterRanges(parameterId);

  1477. 

  1478.         carla_stderr2("carla_get_parameter_ranges(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1479.         return &fallbackParamRanges;

  1480.     }

  1481. 

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

  1483.     return &fallbackParamRanges;

  1484. }

  1485. 

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

  1487. {

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

  1489. 

  1490.     static MidiProgramData midiProgData;

  1491. 

  1492.     // reset

  1493.     midiProgData.bank    = 0;

  1494.     midiProgData.program = 0;

  1495.     midiProgData.name    = gNullCharPtr;

  1496. 

  1497.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &midiProgData);

  1498. 

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

  1500.     {

  1501.         if (midiProgramId < plugin->getMidiProgramCount())

  1502.         {

  1503.             const MidiProgramData& ret(plugin->getMidiProgramData(midiProgramId));

  1504.             carla_copyStruct<MidiProgramData>(midiProgData, ret);

  1505.             checkStringPtr(midiProgData.name);

  1506.             return &midiProgData;

  1507.         }

  1508. 

  1509.         carla_stderr2("carla_get_midi_program_data(%i, %i) - midiProgramId out of bounds", pluginId, midiProgramId);

  1510.         return &midiProgData;

  1511.     }

  1512. 

  1513.     carla_stderr2("carla_get_midi_program_data(%i, %i) - could not find plugin", pluginId, midiProgramId);

  1514.     return &midiProgData;

  1515. }

  1516. 

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

  1518. {

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

  1520. 

  1521.     static CustomData customData;

  1522. 

  1523.     // reset

  1524.     customData.type  = gNullCharPtr;

  1525.     customData.key   = gNullCharPtr;

  1526.     customData.value = gNullCharPtr;

  1527. 

  1528.     CARLA_SAFE_ASSERT_RETURN(gStandalone.engine != nullptr, &customData);

  1529. 

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

  1531.     {

  1532.         if (customDataId < plugin->getCustomDataCount())

  1533.         {

  1534.             const CustomData& ret(plugin->getCustomData(customDataId));

  1535.             carla_copyStruct<CustomData>(customData, ret);

  1536.             checkStringPtr(customData.type);

  1537.             checkStringPtr(customData.key);

  1538.             checkStringPtr(customData.value);

  1539.             return &customData;

  1540.         }

  1541. 

  1542.         carla_stderr2("carla_get_custom_data(%i, %i) - customDataId out of bounds", pluginId, customDataId);

  1543.         return &customData;

  1544.     }

  1545. 

  1546.     carla_stderr2("carla_get_custom_data(%i, %i) - could not find plugin", pluginId, customDataId);

  1547.     return &customData;

  1548. }

  1549. 

  1550. const char* carla_get_chunk_data(uint pluginId)

  1551. {

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

  1553. 

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

  1555. 

  1556.     static CarlaString chunkData;

  1557. 

  1558.     // cleanup

  1559.     chunkData.clear();

  1560. 

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

  1562.     {

  1563.         if (plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS)

  1564.         {

  1565.             void* data = nullptr;

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

  1567. 

  1568.             if (data != nullptr && dataSize > 0)

  1569.             {

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

  1571.                 return chunkData;

  1572.             }

  1573.             else

  1574.                 carla_stderr2("carla_get_chunk_data(%i) - got invalid chunk data", pluginId);

  1575.         }

  1576.         else

  1577.             carla_stderr2("carla_get_chunk_data(%i) - plugin does not use chunks", pluginId);

  1578. 

  1579.         return nullptr;

  1580.     }

  1581. 

  1582.     carla_stderr2("carla_get_chunk_data(%i) - could not find plugin", pluginId);

  1583.     return nullptr;

  1584. }

  1585. 

  1586. // -------------------------------------------------------------------------------------------------------------------

  1587. 

  1588. uint32_t carla_get_parameter_count(uint pluginId)

  1589. {

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

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

  1592. 

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

  1594.         return plugin->getParameterCount();

  1595. 

  1596.     carla_stderr2("carla_get_parameter_count(%i) - could not find plugin", pluginId);

  1597.     return 0;

  1598. }

  1599. 

  1600. uint32_t carla_get_program_count(uint pluginId)

  1601. {

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

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

  1604. 

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

  1606.         return plugin->getProgramCount();

  1607. 

  1608.     carla_stderr2("carla_get_program_count(%i) - could not find plugin", pluginId);

  1609.     return 0;

  1610. }

  1611. 

  1612. uint32_t carla_get_midi_program_count(uint pluginId)

  1613. {

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

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

  1616. 

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

  1618.         return plugin->getMidiProgramCount();

  1619. 

  1620.     carla_stderr2("carla_get_midi_program_count(%i) - could not find plugin", pluginId);

  1621.     return 0;

  1622. }

  1623. 

  1624. uint32_t carla_get_custom_data_count(uint pluginId)

  1625. {

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

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

  1628. 

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

  1630.         return plugin->getCustomDataCount();

  1631. 

  1632.     carla_stderr2("carla_get_custom_data_count(%i) - could not find plugin", pluginId);

  1633.     return 0;

  1634. }

  1635. 

  1636. // -------------------------------------------------------------------------------------------------------------------

  1637. 

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

  1639. {

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

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

  1642. 

  1643.     static char textBuf[STR_MAX+1];

  1644. 

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

  1646.     {

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

  1648.         {

  1649.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1651.             return textBuf;

  1652.         }

  1653. 

  1654.         carla_stderr2("carla_get_parameter_text(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1655.         return nullptr;

  1656.     }

  1657. 

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

  1659.     return nullptr;

  1660. }

  1661. 

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

  1663. {

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

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

  1666. 

  1667.     static char programName[STR_MAX+1];

  1668. 

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

  1670.     {

  1671.         if (programId < plugin->getProgramCount())

  1672.         {

  1673.             carla_zeroChar(programName, STR_MAX+1);

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

  1675.             return programName;

  1676.         }

  1677. 

  1678.         carla_stderr2("carla_get_program_name(%i, %i) - programId out of bounds", pluginId, programId);

  1679.         return nullptr;

  1680.     }

  1681. 

  1682.     carla_stderr2("carla_get_program_name(%i, %i) - could not find plugin", pluginId, programId);

  1683.     return nullptr;

  1684. }

  1685. 

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

  1687. {

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

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

  1690. 

  1691.     static char midiProgramName[STR_MAX+1];

  1692. 

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

  1694.     {

  1695.         if (midiProgramId < plugin->getMidiProgramCount())

  1696.         {

  1697.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1699.             return midiProgramName;

  1700.         }

  1701. 

  1702.         carla_stderr2("carla_get_midi_program_name(%i, %i) - midiProgramId out of bounds", pluginId, midiProgramId);

  1703.         return nullptr;

  1704.     }

  1705. 

  1706.     carla_stderr2("carla_get_midi_program_name(%i, %i) - could not find plugin", pluginId, midiProgramId);

  1707.     return nullptr;

  1708. }

  1709. 

  1710. const char* carla_get_real_plugin_name(uint pluginId)

  1711. {

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

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

  1714. 

  1715.     static char realPluginName[STR_MAX+1];

  1716. 

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

  1718.     {

  1719.         carla_zeroChar(realPluginName, STR_MAX+1);

  1720.         plugin->getRealName(realPluginName);

  1721.         return realPluginName;

  1722.     }

  1723. 

  1724.     carla_stderr2("carla_get_real_plugin_name(%i) - could not find plugin", pluginId);

  1725.     return nullptr;

  1726. }

  1727. 

  1728. // -------------------------------------------------------------------------------------------------------------------

  1729. 

  1730. int32_t carla_get_current_program_index(uint pluginId)

  1731. {

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

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

  1734. 

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

  1736.         return plugin->getCurrentProgram();

  1737. 

  1738.     carla_stderr2("carla_get_current_program_index(%i) - could not find plugin", pluginId);

  1739.     return -1;

  1740. }

  1741. 

  1742. int32_t carla_get_current_midi_program_index(uint pluginId)

  1743. {

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

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

  1746. 

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

  1748.         return plugin->getCurrentMidiProgram();

  1749. 

  1750.     carla_stderr2("carla_get_current_midi_program_index(%i) - could not find plugin", pluginId);

  1751.     return -1;

  1752. }

  1753. 

  1754. // -------------------------------------------------------------------------------------------------------------------

  1755. 

  1756. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1757. {

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

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

  1760. 

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

  1762.     {

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

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

  1765. 

  1766.         carla_stderr2("carla_get_default_parameter_value(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1767.         return 0.0f;

  1768.     }

  1769. 

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

  1771.     return 0.0f;

  1772. }

  1773. 

  1774. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1775. {

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

  1777. 

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

  1779.     {

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

  1781.             return plugin->getParameterValue(parameterId);

  1782. 

  1783.         carla_stderr2("carla_get_current_parameter_value(%i, %i) - parameterId out of bounds", pluginId, parameterId);

  1784.         return 0.0f;

  1785.     }

  1786. 

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

  1788.     return 0.0f;

  1789. }

  1790. 

  1791. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1792. {

  1793. #ifdef BUILD_BRIDGE

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

  1795. #else

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

  1797. #endif

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

  1799. 

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

  1801.         return plugin->getInternalParameterValue(parameterId);

  1802. 

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

  1804.     return 0.0f;

  1805. }

  1806. 

  1807. // -------------------------------------------------------------------------------------------------------------------

  1808. 

  1809. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1810. {

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

  1812. 

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

  1814. }

  1815. 

  1816. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1817. {

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

  1819. 

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

  1821. }

  1822. 

  1823. // -------------------------------------------------------------------------------------------------------------------

  1824. 

  1825. void carla_set_active(uint pluginId, bool onOff)

  1826. {

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

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

  1829. 

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

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

  1832. 

  1833.     carla_stderr2("carla_set_active(%i, %s) - could not find plugin", pluginId, bool2str(onOff));

  1834. }

  1835. 

  1836. #ifndef BUILD_BRIDGE

  1837. void carla_set_drywet(uint pluginId, float value)

  1838. {

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

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

  1841. 

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

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

  1844. 

  1845.     carla_stderr2("carla_set_drywet(%i, %f) - could not find plugin", pluginId, value);

  1846. }

  1847. 

  1848. void carla_set_volume(uint pluginId, float value)

  1849. {

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

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

  1852. 

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

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

  1855. 

  1856.     carla_stderr2("carla_set_volume(%i, %f) - could not find plugin", pluginId, value);

  1857. }

  1858. 

  1859. void carla_set_balance_left(uint pluginId, float value)

  1860. {

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

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

  1863. 

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

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

  1866. 

  1867.     carla_stderr2("carla_set_balance_left(%i, %f) - could not find plugin", pluginId, value);

  1868. }

  1869. 

  1870. void carla_set_balance_right(uint pluginId, float value)

  1871. {

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

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

  1874. 

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

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

  1877. 

  1878.     carla_stderr2("carla_set_balance_right(%i, %f) - could not find plugin", pluginId, value);

  1879. }

  1880. 

  1881. void carla_set_panning(uint pluginId, float value)

  1882. {

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

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

  1885. 

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

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

  1888. 

  1889.     carla_stderr2("carla_set_panning(%i, %f) - could not find plugin", pluginId, value);

  1890. }

  1891. 

  1892. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1893. {

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

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

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

  1897. 

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

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

  1900. 

  1901.     carla_stderr2("carla_set_ctrl_channel(%i, %i) - could not find plugin", pluginId, channel);

  1902. }

  1903. 

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

  1905. {

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

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

  1908. 

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

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

  1911. 

  1912.     carla_stderr2("carla_set_option(%i, %i, %s) - could not find plugin", pluginId, option, bool2str(yesNo));

  1913. }

  1914. #endif

  1915. 

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

  1917. 

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

  1919. {

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

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

  1922. 

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

  1924.     {

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

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

  1927. 

  1928.         carla_stderr2("carla_set_parameter_value(%i, %i, %f) - parameterId out of bounds", pluginId, parameterId, value);

  1929.         return;

  1930.     }

  1931. 

  1932.     carla_stderr2("carla_set_parameter_value(%i, %i, %f) - could not find plugin", pluginId, parameterId, value);

  1933. }

  1934. 

  1935. #ifndef BUILD_BRIDGE

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

  1937. {

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

  1939.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  1941. 

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

  1943.     {

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

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

  1946. 

  1947.         carla_stderr2("carla_set_parameter_midi_channel(%i, %i, %i) - parameterId out of bounds", pluginId, parameterId, channel);

  1948.         return;

  1949.     }

  1950. 

  1951.     carla_stderr2("carla_set_parameter_midi_channel(%i, %i, %i) - could not find plugin", pluginId, parameterId, channel);

  1952. }

  1953. 

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

  1955. {

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

  1957.     CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc <= 0x5F,);

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

  1959. 

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

  1961.     {

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

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

  1964. 

  1965.         carla_stderr2("carla_set_parameter_midi_cc(%i, %i, %i) - parameterId out of bounds", pluginId, parameterId, cc);

  1966.         return;

  1967.     }

  1968. 

  1969.     carla_stderr2("carla_set_parameter_midi_cc(%i, %i, %i) - could not find plugin", pluginId, parameterId, cc);

  1970. }

  1971. #endif

  1972. 

  1973. // -------------------------------------------------------------------------------------------------------------------

  1974. 

  1975. void carla_set_program(uint pluginId, uint32_t programId)

  1976. {

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

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

  1979. 

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

  1981.     {

  1982.         if (programId < plugin->getProgramCount())

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

  1984. 

  1985.         carla_stderr2("carla_set_program(%i, %i) - programId out of bounds", pluginId, programId);

  1986.         return;

  1987.     }

  1988. 

  1989.     carla_stderr2("carla_set_program(%i, %i) - could not find plugin", pluginId, programId);

  1990. }

  1991. 

  1992. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1993. {

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

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

  1996. 

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

  1998.     {

  1999.         if (midiProgramId < plugin->getMidiProgramCount())

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

  2001. 

  2002.         carla_stderr2("carla_set_midi_program(%i, %i) - midiProgramId out of bounds", pluginId, midiProgramId);

  2003.         return;

  2004.     }

  2005. 

  2006.     carla_stderr2("carla_set_midi_program(%i, %i) - could not find plugin", pluginId, midiProgramId);

  2007. }

  2008. 

  2009. // -------------------------------------------------------------------------------------------------------------------

  2010. 

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

  2012. {

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

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

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

  2016.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2018. 

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

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

  2021. 

  2022.     carla_stderr2("carla_set_custom_data(%i, \"%s\", \"%s\", \"%s\") - could not find plugin", pluginId, type, key, value);

  2023. }

  2024. 

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

  2026. {

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

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

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

  2030. 

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

  2032.     {

  2033.         if (plugin->getOptionsEnabled() & CB::PLUGIN_OPTION_USE_CHUNKS)

  2034.         {

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

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

  2037.         }

  2038. 

  2039.         carla_stderr2("carla_set_chunk_data(%i, \"%s\") - plugin does not use chunks", pluginId, chunkData);

  2040.         return;

  2041.     }

  2042. 

  2043.     carla_stderr2("carla_set_chunk_data(%i, \"%s\") - could not find plugin", pluginId, chunkData);

  2044. }

  2045. 

  2046. // -------------------------------------------------------------------------------------------------------------------

  2047. 

  2048. void carla_prepare_for_save(uint pluginId)

  2049. {

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

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

  2052. 

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

  2054.         return plugin->prepareForSave();

  2055. 

  2056.     carla_stderr2("carla_prepare_for_save(%i) - could not find plugin", pluginId);

  2057. }

  2058. 

  2059. void carla_reset_parameters(uint pluginId)

  2060. {

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

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

  2063. 

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

  2065.         return plugin->resetParameters();

  2066. 

  2067.     carla_stderr2("carla_reset_parameters(%i) - could not find plugin", pluginId);

  2068. }

  2069. 

  2070. void carla_randomize_parameters(uint pluginId)

  2071. {

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

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

  2074. 

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

  2076.         return plugin->randomizeParameters();

  2077. 

  2078.     carla_stderr2("carla_randomize_parameters(%i) - could not find plugin", pluginId);

  2079. }

  2080. 

  2081. #ifndef BUILD_BRIDGE

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

  2083. {

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

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

  2086. 

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

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

  2089. 

  2090.     carla_stderr2("carla_send_midi_note(%i, %i, %i, %i) - could not find plugin", pluginId, channel, note, velocity);

  2091. }

  2092. #endif

  2093. 

  2094. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2095. {

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

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

  2098. 

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

  2100.         return plugin->showCustomUI(yesNo);

  2101. 

  2102.     carla_stderr2("carla_show_custom_ui(%i, %s) - could not find plugin", pluginId, bool2str(yesNo));

  2103. }

  2104. 

  2105. // -------------------------------------------------------------------------------------------------------------------

  2106. 

  2107. uint32_t carla_get_buffer_size()

  2108. {

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

  2110.     carla_debug("carla_get_buffer_size()");

  2111. 

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

  2113. }

  2114. 

  2115. double carla_get_sample_rate()

  2116. {

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

  2118.     carla_debug("carla_get_sample_rate()");

  2119. 

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

  2121. }

  2122. 

  2123. // -------------------------------------------------------------------------------------------------------------------

  2124. 

  2125. const char* carla_get_last_error()

  2126. {

  2127.     carla_debug("carla_get_last_error()");

  2128. 

  2129.     if (gStandalone.engine != nullptr)

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

  2131. 

  2132.     return gStandalone.lastError;

  2133. }

  2134. 

  2135. const char* carla_get_host_osc_url_tcp()

  2136. {

  2137.     carla_debug("carla_get_host_osc_url_tcp()");

  2138. 

  2139.     if (gStandalone.engine == nullptr)

  2140.     {

  2141.         carla_stderr2("Engine is not running");

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

  2143.         return nullptr;

  2144.     }

  2145. 

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

  2147. }

  2148. 

  2149. const char* carla_get_host_osc_url_udp()

  2150. {

  2151.     carla_debug("carla_get_host_osc_url_udp()");

  2152. 

  2153.     if (gStandalone.engine == nullptr)

  2154.     {

  2155.         carla_stderr2("Engine is not running");

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

  2157.         return nullptr;

  2158.     }

  2159. 

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

  2161. }

  2162. 

  2163. // -------------------------------------------------------------------------------------------------------------------

  2164. 

  2165. #include "CarlaPluginUI.cpp"

  2166. #include "CarlaDssiUtils.cpp"

  2167. #include "CarlaStateUtils.cpp"

  2168. #include "CarlaJuceEvents.cpp"

  2169. 

  2170. // -------------------------------------------------------------------------------------------------------------------