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

2172 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. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  362. #include "CarlaHostCommon.cpp"

  363. 

  364. // -------------------------------------------------------------------------------------------------------------------

  365. 

  366. uint carla_get_engine_driver_count()

  367. {

  368.     carla_debug("carla_get_engine_driver_count()");

  369. 

  370.     return CarlaEngine::getDriverCount();

  371. }

  372. 

  373. const char* carla_get_engine_driver_name(uint index)

  374. {

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

  376. 

  377.     return CarlaEngine::getDriverName(index);

  378. }

  379. 

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

  381. {

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

  383. 

  384.     return CarlaEngine::getDriverDeviceNames(index);

  385. }

  386. 

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

  388. {

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

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

  391. 

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

  393.     {

  394.         static EngineDriverDeviceInfo devInfo;

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

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

  397. 

  398.         devInfo.hints       = ret->hints;

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

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

  401.         return &devInfo;

  402.     }

  403. 

  404.     return nullptr;

  405. }

  406. 

  407. // -------------------------------------------------------------------------------------------------------------------

  408. 

  409. const CarlaEngine* carla_get_engine()

  410. {

  411.     carla_debug("carla_get_engine()");

  412. 

  413.     return gStandalone.engine;

  414. }

  415. 

  416. // -------------------------------------------------------------------------------------------------------------------

  417. 

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

  419. {

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

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

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

  423. 

  424.     if (gStandalone.engine != nullptr)

  425.     {

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

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

  428.         return false;

  429.     }

  430. 

  431. #ifdef CARLA_OS_WIN

  432.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  433. #endif

  434. 

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

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

  437.     {

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

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

  440.     }

  441. 

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

  443. 

  444.     if (gStandalone.engine == nullptr)

  445.     {

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

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

  448.         return false;

  449.     }

  450. 

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

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

  453. 

  454. #ifdef BUILD_BRIDGE

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

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

  457. #else

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

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

  460. #endif

  461. 

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

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

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

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

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

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

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

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

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

  471. 

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

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

  474. 

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

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

  477. 

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

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

  480. 

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

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

  483. 

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

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

  486. 

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

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

  489. 

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

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

  492. 

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

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

  495. 

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

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

  498. 

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

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

  501. 

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

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

  504. 

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

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

  507. 

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

  509. 

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

  511.     {

  512.         char strBuf[STR_MAX+1];

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

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

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

  516.     }

  517.     else

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

  519. 

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

  521.     {

  522. #ifndef BUILD_BRIDGE

  523.         juce::initialiseJuce_GUI();

  524. #endif

  525.         gStandalone.lastError = "No error";

  526.         return true;

  527.     }

  528.     else

  529.     {

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

  531.         delete gStandalone.engine;

  532.         gStandalone.engine = nullptr;

  533.         return false;

  534.     }

  535. }

  536. 

  537. #ifdef BUILD_BRIDGE

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

  539. {

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

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

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

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

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

  545. 

  546.     if (gStandalone.engine != nullptr)

  547.     {

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

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

  550.         return false;

  551.     }

  552. 

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

  554. 

  555.     if (gStandalone.engine == nullptr)

  556.     {

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

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

  559.         return false;

  560.     }

  561. 

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

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

  564. 

  565.     // forced options for bridge mode

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

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

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

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

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

  571. 

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

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

  574. 

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

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

  577. 

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

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

  580. 

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

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

  583. 

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

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

  586. 

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

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

  589. 

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

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

  592. 

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

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

  595. 

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

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

  598. 

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

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

  601. 

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

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

  604. 

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

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

  607. 

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

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

  610. 

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

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

  613. 

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

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

  616. 

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

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

  619. 

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

  621.     {

  622.         gStandalone.lastError = "No error";

  623.         return true;

  624.     }

  625.     else

  626.     {

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

  628.         delete gStandalone.engine;

  629.         gStandalone.engine = nullptr;

  630.         return false;

  631.     }

  632. }

  633. #endif

  634. 

  635. bool carla_engine_close()

  636. {

  637.     carla_debug("carla_engine_close()");

  638. 

  639.     if (gStandalone.engine == nullptr)

  640.     {

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

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

  643.         return false;

  644.     }

  645. 

  646.     gStandalone.engine->setAboutToClose();

  647.     gStandalone.engine->removeAllPlugins();

  648. 

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

  650. 

  651.     if (! closed)

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

  653. 

  654. #ifndef BUILD_BRIDGE

  655.     juce::shutdownJuce_GUI();

  656. #endif

  657.     delete gStandalone.engine;

  658.     gStandalone.engine = nullptr;

  659. 

  660.     return closed;

  661. }

  662. 

  663. void carla_engine_idle()

  664. {

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

  666. 

  667.     gNSM.idle();

  668.     gStandalone.engine->idle();

  669. }

  670. 

  671. bool carla_is_engine_running()

  672. {

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

  674. }

  675. 

  676. void carla_set_engine_about_to_close()

  677. {

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

  679.     carla_debug("carla_set_engine_about_to_close()");

  680. 

  681.     gStandalone.engine->setAboutToClose();

  682. }

  683. 

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

  685. {

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

  687. 

  688.     gStandalone.engineCallback    = func;

  689.     gStandalone.engineCallbackPtr = ptr;

  690. 

  691.     if (gStandalone.engine != nullptr)

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

  693. 

  694. //#ifdef WANT_LOGS

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

  696. //#endif

  697. }

  698. 

  699. #ifndef BUILD_BRIDGE

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

  701. {

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

  703. 

  704.     switch (option)

  705.     {

  706.     case CB::ENGINE_OPTION_DEBUG:

  707.         break;

  708. 

  709.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  712.         break;

  713. 

  714.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  717.         break;

  718. 

  719.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  722.         break;

  723. 

  724.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  727.         break;

  728. 

  729.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  732.         break;

  733. 

  734.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  737.         break;

  738. 

  739.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  740.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  742.         break;

  743. 

  744.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  745.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  747.         break;

  748. 

  749.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  752.         break;

  753. 

  754.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  755.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  757.         break;

  758. 

  759.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  760.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  762.         break;

  763. 

  764.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  765.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  766. 

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

  768.             delete[] gStandalone.engineOptions.audioDevice;

  769. 

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

  771.         break;

  772. 

  773.     case CB:: ENGINE_OPTION_NSM_INIT:

  774.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  776.         gNSM.announce(value, valueStr);

  777.         break;

  778. 

  779.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  782.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  783. 

  784.         switch (value)

  785.         {

  786.         case CB::PLUGIN_LADSPA:

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

  788.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  790.             break;

  791.         case CB::PLUGIN_DSSI:

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

  793.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  795.             break;

  796.         case CB::PLUGIN_LV2:

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

  798.                 delete[] gStandalone.engineOptions.pathLV2;

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

  800.             break;

  801.         case CB::PLUGIN_VST:

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

  803.                 delete[] gStandalone.engineOptions.pathVST;

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

  805.             break;

  806.         case CB::PLUGIN_VST3:

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

  808.                 delete[] gStandalone.engineOptions.pathVST3;

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

  810.             break;

  811.         case CB::PLUGIN_AU:

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

  813.                 delete[] gStandalone.engineOptions.pathAU;

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

  815.             break;

  816.         case CB::PLUGIN_GIG:

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

  818.                 delete[] gStandalone.engineOptions.pathGIG;

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

  820.             break;

  821.         case CB::PLUGIN_SF2:

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

  823.                 delete[] gStandalone.engineOptions.pathSF2;

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

  825.             break;

  826.         case CB::PLUGIN_SFZ:

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

  828.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  830.             break;

  831.         }

  832.         break;

  833. 

  834.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  836. 

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

  838.             delete[] gStandalone.engineOptions.binaryDir;

  839. 

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

  841.         break;

  842. 

  843.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  845. 

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

  847.             delete[] gStandalone.engineOptions.resourceDir;

  848. 

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

  850.         break;

  851. 

  852.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  855.         break;

  856. 

  857.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  860.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  862.         break;

  863.     }

  864. 

  865.     if (gStandalone.engine != nullptr)

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

  867. }

  868. #endif

  869. 

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

  871. {

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

  873. 

  874.     gStandalone.fileCallback    = func;

  875.     gStandalone.fileCallbackPtr = ptr;

  876. 

  877.     if (gStandalone.engine != nullptr)

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

  879. }

  880. 

  881. // -------------------------------------------------------------------------------------------------------------------

  882. 

  883. bool carla_load_file(const char* filename)

  884. {

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

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

  887. 

  888.     if (gStandalone.engine != nullptr)

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

  890. 

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

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

  893.     return false;

  894. }

  895. 

  896. bool carla_load_project(const char* filename)

  897. {

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

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

  900. 

  901.     if (gStandalone.engine != nullptr)

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

  903. 

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

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

  906.     return false;

  907. }

  908. 

  909. bool carla_save_project(const char* filename)

  910. {

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

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

  913. 

  914.     if (gStandalone.engine != nullptr)

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

  916. 

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

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

  919.     return false;

  920. }

  921. 

  922. #ifndef BUILD_BRIDGE

  923. // -------------------------------------------------------------------------------------------------------------------

  924. 

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

  926. {

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

  928. 

  929.     if (gStandalone.engine != nullptr)

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

  931. 

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

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

  934.     return false;

  935. }

  936. 

  937. bool carla_patchbay_disconnect(uint connectionId)

  938. {

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

  940. 

  941.     if (gStandalone.engine != nullptr)

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

  943. 

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

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

  946.     return false;

  947. }

  948. 

  949. bool carla_patchbay_refresh(bool external)

  950. {

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

  952. 

  953.     if (gStandalone.engine != nullptr)

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

  955. 

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

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

  958.     return false;

  959. }

  960. 

  961. // -------------------------------------------------------------------------------------------------------------------

  962. 

  963. void carla_transport_play()

  964. {

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

  966.     carla_debug("carla_transport_play()");

  967. 

  968.     gStandalone.engine->transportPlay();

  969. }

  970. 

  971. void carla_transport_pause()

  972. {

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

  974.     carla_debug("carla_transport_pause()");

  975. 

  976.     gStandalone.engine->transportPause();

  977. }

  978. 

  979. void carla_transport_relocate(uint64_t frame)

  980. {

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

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

  983. 

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

  985. }

  986. 

  987. uint64_t carla_get_current_transport_frame()

  988. {

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

  990. 

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

  992.     return timeInfo.frame;

  993. }

  994. 

  995. const CarlaTransportInfo* carla_get_transport_info()

  996. {

  997.     static CarlaTransportInfo retInfo;

  998. 

  999.     // reset

  1000.     retInfo.playing = false;

  1001.     retInfo.frame   = 0;

  1002.     retInfo.bar     = 0;

  1003.     retInfo.beat    = 0;

  1004.     retInfo.tick    = 0;

  1005.     retInfo.bpm     = 0.0;

  1006. 

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

  1008. 

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

  1010. 

  1011.     retInfo.playing = timeInfo.playing;

  1012.     retInfo.frame   = timeInfo.frame;

  1013. 

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

  1015.     {

  1016.         retInfo.bar  = timeInfo.bbt.bar;

  1017.         retInfo.beat = timeInfo.bbt.beat;

  1018.         retInfo.tick = timeInfo.bbt.tick;

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

  1020.     }

  1021. 

  1022.     return &retInfo;

  1023. }

  1024. #endif

  1025. 

  1026. // -------------------------------------------------------------------------------------------------------------------

  1027. 

  1028. uint32_t carla_get_current_plugin_count()

  1029. {

  1030.     if (gStandalone.engine != nullptr)

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

  1032. 

  1033.     return 0;

  1034. }

  1035. 

  1036. uint32_t carla_get_max_plugin_number()

  1037. {

  1038.     if (gStandalone.engine != nullptr)

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

  1040. 

  1041.     return 0;

  1042. }

  1043. 

  1044. // -------------------------------------------------------------------------------------------------------------------

  1045. 

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

  1047. {

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

  1049.     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);

  1050. 

  1051.     if (gStandalone.engine != nullptr)

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

  1053. 

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

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

  1056.     return false;

  1057. }

  1058. 

  1059. bool carla_remove_plugin(uint pluginId)

  1060. {

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

  1062. 

  1063.     if (gStandalone.engine != nullptr)

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

  1065. 

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

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

  1068.     return false;

  1069. }

  1070. 

  1071. bool carla_remove_all_plugins()

  1072. {

  1073.     carla_debug("carla_remove_all_plugins()");

  1074. 

  1075.     if (gStandalone.engine != nullptr)

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

  1077. 

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

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

  1080.     return false;

  1081. }

  1082. 

  1083. #ifndef BUILD_BRIDGE

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

  1085. {

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

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

  1088. 

  1089.     if (gStandalone.engine != nullptr)

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

  1091. 

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

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

  1094.     return nullptr;

  1095. }

  1096. 

  1097. bool carla_clone_plugin(uint pluginId)

  1098. {

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

  1100. 

  1101.     if (gStandalone.engine != nullptr)

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

  1103. 

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

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

  1106.     return false;

  1107. }

  1108. 

  1109. bool carla_replace_plugin(uint pluginId)

  1110. {

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

  1112. 

  1113.     if (gStandalone.engine != nullptr)

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

  1115. 

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

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

  1118.     return false;

  1119. }

  1120. 

  1121. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1122. {

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

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

  1125. 

  1126.     if (gStandalone.engine != nullptr)

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

  1128. 

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

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

  1131.     return false;

  1132. }

  1133. #endif

  1134. 

  1135. // -------------------------------------------------------------------------------------------------------------------

  1136. 

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

  1138. {

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

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

  1141. 

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

  1143.     {

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

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

  1146.         return false;

  1147.     }

  1148. 

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

  1150.         return plugin->loadStateFromFile(filename);

  1151. 

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

  1153.     return false;

  1154. }

  1155. 

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

  1157. {

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

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

  1160. 

  1161.     if (gStandalone.engine == nullptr)

  1162.     {

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

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

  1165.         return false;

  1166.     }

  1167. 

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

  1169. 

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

  1171.         return plugin->saveStateToFile(filename);

  1172. 

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

  1174.     return false;

  1175. }

  1176. 

  1177. // -------------------------------------------------------------------------------------------------------------------

  1178. 

  1179. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1180. {

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

  1182. 

  1183.     static CarlaPluginInfo info;

  1184. 

  1185.     // reset

  1186.     info.type             = CB::PLUGIN_NONE;

  1187.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1188.     info.hints            = 0x0;

  1189.     info.optionsAvailable = 0x0;

  1190.     info.optionsEnabled   = 0x0;

  1191.     info.filename         = gNullCharPtr;

  1192.     info.name             = gNullCharPtr;

  1193.     info.iconName         = gNullCharPtr;

  1194.     info.uniqueId         = 0;

  1195. 

  1196.     // cleanup

  1197.     if (info.label != gNullCharPtr)

  1198.     {

  1199.         delete[] info.label;

  1200.         info.label = gNullCharPtr;

  1201.     }

  1202. 

  1203.     if (info.maker != gNullCharPtr)

  1204.     {

  1205.         delete[] info.maker;

  1206.         info.maker = gNullCharPtr;

  1207.     }

  1208. 

  1209.     if (info.copyright != gNullCharPtr)

  1210.     {

  1211.         delete[] info.copyright;

  1212.         info.copyright = gNullCharPtr;

  1213.     }

  1214. 

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

  1216. 

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

  1218.     {

  1219.         char strBufLabel[STR_MAX+1];

  1220.         char strBufMaker[STR_MAX+1];

  1221.         char strBufCopyright[STR_MAX+1];

  1222. 

  1223.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1224.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1225.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1226. 

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

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

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

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

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

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

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

  1234. 

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

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

  1237. 

  1238.         plugin->getLabel(strBufLabel);

  1239.         info.label = carla_strdup_safe(strBufLabel);

  1240. 

  1241.         plugin->getMaker(strBufMaker);

  1242.         info.maker = carla_strdup_safe(strBufMaker);

  1243. 

  1244.         plugin->getCopyright(strBufCopyright);

  1245.         info.copyright = carla_strdup_safe(strBufCopyright);

  1246. 

  1247.         checkStringPtr(info.filename);

  1248.         checkStringPtr(info.name);

  1249.         checkStringPtr(info.iconName);

  1250.         checkStringPtr(info.label);

  1251.         checkStringPtr(info.maker);

  1252.         checkStringPtr(info.copyright);

  1253. 

  1254.         return &info;

  1255.     }

  1256. 

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

  1258.     return &info;

  1259. }

  1260. 

  1261. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1262. {

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

  1264. 

  1265.     static CarlaPortCountInfo info;

  1266. 

  1267.     // reset

  1268.     info.ins   = 0;

  1269.     info.outs  = 0;

  1270. 

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

  1272. 

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

  1274.     {

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

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

  1277.         return &info;

  1278.     }

  1279. 

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

  1281.     return &info;

  1282. }

  1283. 

  1284. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1285. {

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

  1287. 

  1288.     static CarlaPortCountInfo info;

  1289. 

  1290.     // reset

  1291.     info.ins   = 0;

  1292.     info.outs  = 0;

  1293. 

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

  1295. 

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

  1297.     {

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

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

  1300.         return &info;

  1301.     }

  1302. 

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

  1304.     return &info;

  1305. }

  1306. 

  1307. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1308. {

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

  1310. 

  1311.     static CarlaPortCountInfo info;

  1312. 

  1313.     // reset

  1314.     info.ins   = 0;

  1315.     info.outs  = 0;

  1316. 

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

  1318. 

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

  1320.     {

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

  1322.         return &info;

  1323.     }

  1324. 

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

  1326.     return &info;

  1327. }

  1328. 

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

  1330. {

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

  1332. 

  1333.     static CarlaParameterInfo info;

  1334. 

  1335.     // reset

  1336.     info.scalePointCount = 0;

  1337. 

  1338.     // cleanup

  1339.     if (info.name != gNullCharPtr)

  1340.     {

  1341.         delete[] info.name;

  1342.         info.name = gNullCharPtr;

  1343.     }

  1344. 

  1345.     if (info.symbol != gNullCharPtr)

  1346.     {

  1347.         delete[] info.symbol;

  1348.         info.symbol = gNullCharPtr;

  1349.     }

  1350. 

  1351.     if (info.unit != gNullCharPtr)

  1352.     {

  1353.         delete[] info.unit;

  1354.         info.unit = gNullCharPtr;

  1355.     }

  1356. 

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

  1358. 

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

  1360.     {

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

  1362.         {

  1363.             char strBufName[STR_MAX+1];

  1364.             char strBufSymbol[STR_MAX+1];

  1365.             char strBufUnit[STR_MAX+1];

  1366. 

  1367.             carla_zeroChar(strBufName, STR_MAX+1);

  1368.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1369.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1370. 

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

  1372. 

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

  1374.             info.name = carla_strdup_safe(strBufName);

  1375. 

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

  1377.             info.symbol = carla_strdup_safe(strBufSymbol);

  1378. 

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

  1380.             info.unit = carla_strdup_safe(strBufUnit);

  1381. 

  1382.             checkStringPtr(info.name);

  1383.             checkStringPtr(info.symbol);

  1384.             checkStringPtr(info.unit);

  1385.         }

  1386.         else

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

  1388. 

  1389.         return &info;

  1390.     }

  1391. 

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

  1393.     return &info;

  1394. }

  1395. 

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

  1397. {

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

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

  1400. 

  1401.     static CarlaScalePointInfo info;

  1402. 

  1403.     // reset

  1404.     info.value = 0.0f;

  1405. 

  1406.     // cleanup

  1407.     if (info.label != gNullCharPtr)

  1408.     {

  1409.         delete[] info.label;

  1410.         info.label = gNullCharPtr;

  1411.     }

  1412. 

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

  1414. 

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

  1416.     {

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

  1418.         {

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

  1420.             {

  1421.                 char strBufLabel[STR_MAX+1];

  1422.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1423. 

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

  1425. 

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

  1427.                 info.label = carla_strdup_safe(strBufLabel);

  1428.                 checkStringPtr(info.label);

  1429.             }

  1430.             else

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

  1432.         }

  1433.         else

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

  1435. 

  1436.         return &info;

  1437.     }

  1438. 

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

  1440.     return &info;

  1441. }

  1442. 

  1443. // -------------------------------------------------------------------------------------------------------------------

  1444. 

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

  1446. {

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

  1448. 

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

  1450. 

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

  1452. 

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

  1454.     {

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

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

  1457. 

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

  1459.         return &fallbackParameterData;

  1460.     }

  1461. 

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

  1463.     return &fallbackParameterData;

  1464. }

  1465. 

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

  1467. {

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

  1469. 

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

  1471. 

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

  1473. 

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

  1475.     {

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

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

  1478. 

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

  1480.         return &fallbackParamRanges;

  1481.     }

  1482. 

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

  1484.     return &fallbackParamRanges;

  1485. }

  1486. 

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

  1488. {

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

  1490. 

  1491.     static MidiProgramData midiProgData;

  1492. 

  1493.     // reset

  1494.     midiProgData.bank    = 0;

  1495.     midiProgData.program = 0;

  1496.     midiProgData.name    = gNullCharPtr;

  1497. 

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

  1499. 

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

  1501.     {

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

  1503.         {

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

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

  1506.             checkStringPtr(midiProgData.name);

  1507.             return &midiProgData;

  1508.         }

  1509. 

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

  1511.         return &midiProgData;

  1512.     }

  1513. 

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

  1515.     return &midiProgData;

  1516. }

  1517. 

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

  1519. {

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

  1521. 

  1522.     static CustomData customData;

  1523. 

  1524.     // reset

  1525.     customData.type  = gNullCharPtr;

  1526.     customData.key   = gNullCharPtr;

  1527.     customData.value = gNullCharPtr;

  1528. 

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

  1530. 

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

  1532.     {

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

  1534.         {

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

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

  1537.             checkStringPtr(customData.type);

  1538.             checkStringPtr(customData.key);

  1539.             checkStringPtr(customData.value);

  1540.             return &customData;

  1541.         }

  1542. 

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

  1544.         return &customData;

  1545.     }

  1546. 

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

  1548.     return &customData;

  1549. }

  1550. 

  1551. const char* carla_get_chunk_data(uint pluginId)

  1552. {

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

  1554. 

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

  1556. 

  1557.     static CarlaString chunkData;

  1558. 

  1559.     // cleanup

  1560.     chunkData.clear();

  1561. 

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

  1563.     {

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

  1565.         {

  1566.             void* data = nullptr;

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

  1568. 

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

  1570.             {

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

  1572.                 return chunkData;

  1573.             }

  1574.             else

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

  1576.         }

  1577.         else

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

  1579. 

  1580.         return nullptr;

  1581.     }

  1582. 

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

  1584.     return nullptr;

  1585. }

  1586. 

  1587. // -------------------------------------------------------------------------------------------------------------------

  1588. 

  1589. uint32_t carla_get_parameter_count(uint pluginId)

  1590. {

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

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

  1593. 

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

  1595.         return plugin->getParameterCount();

  1596. 

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

  1598.     return 0;

  1599. }

  1600. 

  1601. uint32_t carla_get_program_count(uint pluginId)

  1602. {

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

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

  1605. 

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

  1607.         return plugin->getProgramCount();

  1608. 

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

  1610.     return 0;

  1611. }

  1612. 

  1613. uint32_t carla_get_midi_program_count(uint pluginId)

  1614. {

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

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

  1617. 

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

  1619.         return plugin->getMidiProgramCount();

  1620. 

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

  1622.     return 0;

  1623. }

  1624. 

  1625. uint32_t carla_get_custom_data_count(uint pluginId)

  1626. {

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

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

  1629. 

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

  1631.         return plugin->getCustomDataCount();

  1632. 

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

  1634.     return 0;

  1635. }

  1636. 

  1637. // -------------------------------------------------------------------------------------------------------------------

  1638. 

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

  1640. {

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

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

  1643. 

  1644.     static char textBuf[STR_MAX+1];

  1645. 

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

  1647.     {

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

  1649.         {

  1650.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1652.             return textBuf;

  1653.         }

  1654. 

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

  1656.         return nullptr;

  1657.     }

  1658. 

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

  1660.     return nullptr;

  1661. }

  1662. 

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

  1664. {

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

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

  1667. 

  1668.     static char programName[STR_MAX+1];

  1669. 

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

  1671.     {

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

  1673.         {

  1674.             carla_zeroChar(programName, STR_MAX+1);

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

  1676.             return programName;

  1677.         }

  1678. 

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

  1680.         return nullptr;

  1681.     }

  1682. 

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

  1684.     return nullptr;

  1685. }

  1686. 

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

  1688. {

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

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

  1691. 

  1692.     static char midiProgramName[STR_MAX+1];

  1693. 

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

  1695.     {

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

  1697.         {

  1698.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1700.             return midiProgramName;

  1701.         }

  1702. 

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

  1704.         return nullptr;

  1705.     }

  1706. 

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

  1708.     return nullptr;

  1709. }

  1710. 

  1711. const char* carla_get_real_plugin_name(uint pluginId)

  1712. {

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

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

  1715. 

  1716.     static char realPluginName[STR_MAX+1];

  1717. 

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

  1719.     {

  1720.         carla_zeroChar(realPluginName, STR_MAX+1);

  1721.         plugin->getRealName(realPluginName);

  1722.         return realPluginName;

  1723.     }

  1724. 

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

  1726.     return nullptr;

  1727. }

  1728. 

  1729. // -------------------------------------------------------------------------------------------------------------------

  1730. 

  1731. int32_t carla_get_current_program_index(uint pluginId)

  1732. {

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

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

  1735. 

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

  1737.         return plugin->getCurrentProgram();

  1738. 

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

  1740.     return -1;

  1741. }

  1742. 

  1743. int32_t carla_get_current_midi_program_index(uint pluginId)

  1744. {

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

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

  1747. 

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

  1749.         return plugin->getCurrentMidiProgram();

  1750. 

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

  1752.     return -1;

  1753. }

  1754. 

  1755. // -------------------------------------------------------------------------------------------------------------------

  1756. 

  1757. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1758. {

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

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

  1761. 

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

  1763.     {

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

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

  1766. 

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

  1768.         return 0.0f;

  1769.     }

  1770. 

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

  1772.     return 0.0f;

  1773. }

  1774. 

  1775. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1776. {

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

  1778. 

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

  1780.     {

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

  1782.             return plugin->getParameterValue(parameterId);

  1783. 

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

  1785.         return 0.0f;

  1786.     }

  1787. 

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

  1789.     return 0.0f;

  1790. }

  1791. 

  1792. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1793. {

  1794. #ifdef BUILD_BRIDGE

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

  1796. #else

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

  1798. #endif

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

  1800. 

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

  1802.         return plugin->getInternalParameterValue(parameterId);

  1803. 

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

  1805.     return 0.0f;

  1806. }

  1807. 

  1808. // -------------------------------------------------------------------------------------------------------------------

  1809. 

  1810. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1811. {

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

  1813. 

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

  1815. }

  1816. 

  1817. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1818. {

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

  1820. 

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

  1822. }

  1823. 

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

  1825. 

  1826. void carla_set_active(uint pluginId, bool onOff)

  1827. {

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

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

  1830. 

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

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

  1833. 

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

  1835. }

  1836. 

  1837. #ifndef BUILD_BRIDGE

  1838. void carla_set_drywet(uint pluginId, float value)

  1839. {

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

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

  1842. 

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

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

  1845. 

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

  1847. }

  1848. 

  1849. void carla_set_volume(uint pluginId, float value)

  1850. {

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

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

  1853. 

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

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

  1856. 

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

  1858. }

  1859. 

  1860. void carla_set_balance_left(uint pluginId, float value)

  1861. {

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

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

  1864. 

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

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

  1867. 

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

  1869. }

  1870. 

  1871. void carla_set_balance_right(uint pluginId, float value)

  1872. {

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

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

  1875. 

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

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

  1878. 

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

  1880. }

  1881. 

  1882. void carla_set_panning(uint pluginId, float value)

  1883. {

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

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

  1886. 

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

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

  1889. 

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

  1891. }

  1892. 

  1893. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1894. {

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

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

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

  1898. 

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

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

  1901. 

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

  1903. }

  1904. 

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

  1906. {

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

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

  1909. 

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

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

  1912. 

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

  1914. }

  1915. #endif

  1916. 

  1917. // -------------------------------------------------------------------------------------------------------------------

  1918. 

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

  1920. {

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

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

  1923. 

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

  1925.     {

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

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

  1928. 

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

  1930.         return;

  1931.     }

  1932. 

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

  1934. }

  1935. 

  1936. #ifndef BUILD_BRIDGE

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

  1938. {

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

  1940.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  1942. 

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

  1944.     {

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

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

  1947. 

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

  1949.         return;

  1950.     }

  1951. 

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

  1953. }

  1954. 

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

  1956. {

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

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

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

  1960. 

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

  1962.     {

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

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

  1965. 

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

  1967.         return;

  1968.     }

  1969. 

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

  1971. }

  1972. #endif

  1973. 

  1974. // -------------------------------------------------------------------------------------------------------------------

  1975. 

  1976. void carla_set_program(uint pluginId, uint32_t programId)

  1977. {

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

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

  1980. 

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

  1982.     {

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

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

  1985. 

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

  1987.         return;

  1988.     }

  1989. 

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

  1991. }

  1992. 

  1993. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1994. {

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

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

  1997. 

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

  1999.     {

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

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

  2002. 

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

  2004.         return;

  2005.     }

  2006. 

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

  2008. }

  2009. 

  2010. // -------------------------------------------------------------------------------------------------------------------

  2011. 

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

  2013. {

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

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

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

  2017.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2019. 

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

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

  2022. 

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

  2024. }

  2025. 

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

  2027. {

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

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

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

  2031. 

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

  2033.     {

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

  2035.         {

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

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

  2038.         }

  2039. 

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

  2041.         return;

  2042.     }

  2043. 

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

  2045. }

  2046. 

  2047. // -------------------------------------------------------------------------------------------------------------------

  2048. 

  2049. void carla_prepare_for_save(uint pluginId)

  2050. {

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

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

  2053. 

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

  2055.         return plugin->prepareForSave();

  2056. 

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

  2058. }

  2059. 

  2060. void carla_reset_parameters(uint pluginId)

  2061. {

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

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

  2064. 

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

  2066.         return plugin->resetParameters();

  2067. 

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

  2069. }

  2070. 

  2071. void carla_randomize_parameters(uint pluginId)

  2072. {

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

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

  2075. 

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

  2077.         return plugin->randomizeParameters();

  2078. 

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

  2080. }

  2081. 

  2082. #ifndef BUILD_BRIDGE

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

  2084. {

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

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

  2087. 

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

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

  2090. 

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

  2092. }

  2093. #endif

  2094. 

  2095. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2096. {

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

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

  2099. 

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

  2101.         return plugin->showCustomUI(yesNo);

  2102. 

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

  2104. }

  2105. 

  2106. // -------------------------------------------------------------------------------------------------------------------

  2107. 

  2108. uint32_t carla_get_buffer_size()

  2109. {

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

  2111.     carla_debug("carla_get_buffer_size()");

  2112. 

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

  2114. }

  2115. 

  2116. double carla_get_sample_rate()

  2117. {

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

  2119.     carla_debug("carla_get_sample_rate()");

  2120. 

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

  2122. }

  2123. 

  2124. // -------------------------------------------------------------------------------------------------------------------

  2125. 

  2126. const char* carla_get_last_error()

  2127. {

  2128.     carla_debug("carla_get_last_error()");

  2129. 

  2130.     if (gStandalone.engine != nullptr)

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

  2132. 

  2133.     return gStandalone.lastError;

  2134. }

  2135. 

  2136. const char* carla_get_host_osc_url_tcp()

  2137. {

  2138.     carla_debug("carla_get_host_osc_url_tcp()");

  2139. 

  2140.     if (gStandalone.engine == nullptr)

  2141.     {

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

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

  2144.         return nullptr;

  2145.     }

  2146. 

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

  2148. }

  2149. 

  2150. const char* carla_get_host_osc_url_udp()

  2151. {

  2152.     carla_debug("carla_get_host_osc_url_udp()");

  2153. 

  2154.     if (gStandalone.engine == nullptr)

  2155.     {

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

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

  2158.         return nullptr;

  2159.     }

  2160. 

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

  2162. }

  2163. 

  2164. // -------------------------------------------------------------------------------------------------------------------

  2165. 

  2166. #include "CarlaPluginUI.cpp"

  2167. #include "CarlaDssiUtils.cpp"

  2168. #include "CarlaStateUtils.cpp"

  2169. #include "CarlaJuceEvents.cpp"

  2170. 

  2171. // -------------------------------------------------------------------------------------------------------------------