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

2171 lines
76KB
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. #endif

  79.     }

  80. 

  81.     ~CarlaBackendStandalone()

  82.     {

  83.         CARLA_SAFE_ASSERT(engine == nullptr);

  84.     }

  85. 

  86.     CARLA_PREVENT_HEAP_ALLOCATION

  87.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  88. };

  89. 

  90. static CarlaBackendStandalone gStandalone;

  91. 

  92. // -------------------------------------------------------------------------------------------------------------------

  93. // NSM support

  94. 

  95. #define NSM_API_VERSION_MAJOR 1

  96. #define NSM_API_VERSION_MINOR 2

  97. 

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

  99. #define NSM_CLIENT_FEATURES ":switch:"

  100. 

  101. class CarlaNSM

  102. {

  103. public:

  104.     CarlaNSM() noexcept

  105.         : fOscServer(nullptr),

  106.           fClientId(),

  107.           fProjectPath(),

  108.           fHasBroadcast(false),

  109.           fHasShowHideUI(false) {}

  110. 

  111.     ~CarlaNSM()

  112.     {

  113.         if (fOscServer != nullptr)

  114.         {

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

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

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

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

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

  120.             lo_server_free(fOscServer);

  121.             fOscServer = nullptr;

  122.         }

  123.     }

  124. 

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

  126.     {

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

  128. 

  129.         if (NSM_URL == nullptr)

  130.             return;

  131. 

  132.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  133.         CARLA_SAFE_ASSERT_RETURN(addr != nullptr,);

  134. 

  135.         const int proto = lo_address_get_protocol(addr);

  136. 

  137.         if (fOscServer == nullptr)

  138.         {

  139.             // create new OSC server

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

  141. 

  142.             // register message handlers and start OSC thread

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

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

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

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

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

  148.             // /nsm/client/session_is_loaded

  149.         }

  150. 

  151. #ifndef BUILD_ANSI_TEST

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

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

  154. #endif

  155. 

  156.         lo_address_free(addr);

  157.     }

  158. 

  159.     void idle() noexcept

  160.     {

  161.         if (fOscServer == nullptr)

  162.             return;

  163. 

  164.         for (;;)

  165.         {

  166.             try {

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

  168.                     break;

  169.             } CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  170.         }

  171.     }

  172. 

  173. protected:

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

  175.     {

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

  177. 

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

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

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

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

  182. 

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

  184. 

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

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

  187. 

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

  189. 

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

  191. 

  192.         return 0;

  193. 

  194. #ifndef DEBUG

  195.         // unused

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

  197. #endif

  198.     }

  199. 

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

  201.     {

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

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

  204. 

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

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

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

  208. 

  209.         if (! carla_is_engine_running())

  210.         {

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

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

  213. 

  214.             carla_engine_init("JACK", clientId);

  215.         }

  216.         else

  217.         {

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

  219. 

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

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

  222.         }

  223. 

  224.         fClientId = clientId;

  225. 

  226.         fProjectPath  = projectPath;

  227.         fProjectPath += ".carxp";

  228. 

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

  230. 

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

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

  233. 

  234. #ifndef BUILD_ANSI_TEST

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

  236. #endif

  237. 

  238. #if 0

  239.         if (fHasBroadcast)

  240.         {

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

  242. 

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

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

  245. 

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

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

  248. 

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

  250. 

  251.             std::free(url);

  252. 

  253.             carla_stdout("Broadcast sent!");

  254.         }

  255.         else

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

  257. #endif

  258. 

  259.         return 0;

  260. 

  261. #ifndef DEBUG

  262.         // unused

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

  264. #endif

  265.     }

  266. 

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

  268.     {

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

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

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

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

  273. 

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

  275. 

  276. #ifndef BUILD_ANSI_TEST

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

  278. #endif

  279. 

  280.         return 0;

  281. 

  282. #ifndef DEBUG

  283.         // unused

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

  285. #endif

  286.     }

  287. 

  288. #if 0

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

  290.     {

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

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

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

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

  295. 

  296. #ifndef BUILD_ANSI_TEST

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

  298. #endif

  299. 

  300.         return 0;

  301.     }

  302. #endif

  303. 

  304. private:

  305.     lo_server fOscServer;

  306. 

  307.     CarlaString fClientId;

  308.     CarlaString fProjectPath;

  309. 

  310.     bool fHasBroadcast;

  311.     bool fHasShowHideUI;

  312. 

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

  314. 

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

  316.     {

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

  318.     }

  319. 

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

  321.     {

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

  323.     }

  324. 

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

  326.     {

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

  328.     }

  329. 

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

  331.     {

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

  333.     }

  334. 

  335. #if 0

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

  337.     {

  338.         return handlePtr->handleShowHideGui(true);

  339.     }

  340. 

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

  342.     {

  343.         return handlePtr->handleShowHideGui(false);

  344.     }

  345. #endif

  346. 

  347.     #undef handlePtr

  348. 

  349.     CARLA_PREVENT_HEAP_ALLOCATION

  350.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  351. };

  352. 

  353. static CarlaNSM gNSM;

  354. 

  355. // -------------------------------------------------------------------------------------------------------------------

  356. // API

  357. 

  358. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  359. #include "CarlaHostCommon.cpp"

  360. 

  361. // -------------------------------------------------------------------------------------------------------------------

  362. 

  363. uint carla_get_engine_driver_count()

  364. {

  365.     carla_debug("carla_get_engine_driver_count()");

  366. 

  367.     return CarlaEngine::getDriverCount();

  368. }

  369. 

  370. const char* carla_get_engine_driver_name(uint index)

  371. {

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

  373. 

  374.     return CarlaEngine::getDriverName(index);

  375. }

  376. 

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

  378. {

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

  380. 

  381.     return CarlaEngine::getDriverDeviceNames(index);

  382. }

  383. 

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

  385. {

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

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

  388. 

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

  390.     {

  391.         static EngineDriverDeviceInfo devInfo;

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

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

  394. 

  395.         devInfo.hints       = ret->hints;

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

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

  398.         return &devInfo;

  399.     }

  400. 

  401.     return nullptr;

  402. }

  403. 

  404. // -------------------------------------------------------------------------------------------------------------------

  405. 

  406. CarlaEngine* carla_get_engine()

  407. {

  408.     carla_debug("carla_get_engine()");

  409. 

  410.     return gStandalone.engine;

  411. }

  412. 

  413. // -------------------------------------------------------------------------------------------------------------------

  414. 

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

  416. {

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

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

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

  420. 

  421.     if (gStandalone.engine != nullptr)

  422.     {

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

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

  425.         return false;

  426.     }

  427. 

  428. #ifdef CARLA_OS_WIN

  429.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  430. #endif

  431. 

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

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

  434.     {

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

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

  437.     }

  438. 

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

  440. 

  441.     if (gStandalone.engine == nullptr)

  442.     {

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

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

  445.         return false;

  446.     }

  447. 

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

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

  450. 

  451. #ifdef BUILD_BRIDGE

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

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

  454. #else

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

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

  457. #endif

  458. 

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

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

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

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

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

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

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

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

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

  468. 

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

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

  471. 

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

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

  474. 

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

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

  477. 

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

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

  480. 

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

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

  483. 

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

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

  486. 

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

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

  489. 

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

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

  492. 

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

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

  495. 

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

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

  498. 

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

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

  501. 

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

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

  504. 

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

  506. 

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

  508.     {

  509.         char strBuf[STR_MAX+1];

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

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

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

  513.     }

  514.     else

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

  516. 

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

  518.     {

  519. #ifndef BUILD_BRIDGE

  520.         juce::initialiseJuce_GUI();

  521. #endif

  522.         gStandalone.lastError = "No error";

  523.         return true;

  524.     }

  525.     else

  526.     {

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

  528.         delete gStandalone.engine;

  529.         gStandalone.engine = nullptr;

  530.         return false;

  531.     }

  532. }

  533. 

  534. #ifdef BUILD_BRIDGE

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

  536. {

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

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

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

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

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

  542. 

  543.     if (gStandalone.engine != nullptr)

  544.     {

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

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

  547.         return false;

  548.     }

  549. 

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

  551. 

  552.     if (gStandalone.engine == nullptr)

  553.     {

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

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

  556.         return false;

  557.     }

  558. 

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

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

  561. 

  562.     // forced options for bridge mode

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

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

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

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

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

  568. 

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

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

  571. 

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

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

  574. 

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

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

  577. 

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

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

  580. 

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

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

  583. 

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

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

  586. 

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

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

  589. 

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

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

  592. 

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

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

  595. 

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

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

  598. 

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

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

  601. 

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

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

  604. 

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

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

  607. 

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

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

  610. 

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

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

  613. 

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

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

  616. 

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

  618.     {

  619.         gStandalone.lastError = "No error";

  620.         return true;

  621.     }

  622.     else

  623.     {

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

  625.         delete gStandalone.engine;

  626.         gStandalone.engine = nullptr;

  627.         return false;

  628.     }

  629. }

  630. #endif

  631. 

  632. bool carla_engine_close()

  633. {

  634.     carla_debug("carla_engine_close()");

  635. 

  636.     if (gStandalone.engine == nullptr)

  637.     {

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

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

  640.         return false;

  641.     }

  642. 

  643.     gStandalone.engine->setAboutToClose();

  644.     gStandalone.engine->removeAllPlugins();

  645. 

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

  647. 

  648.     if (! closed)

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

  650. 

  651. #ifndef BUILD_BRIDGE

  652.     juce::shutdownJuce_GUI();

  653. #endif

  654.     delete gStandalone.engine;

  655.     gStandalone.engine = nullptr;

  656. 

  657.     return closed;

  658. }

  659. 

  660. void carla_engine_idle()

  661. {

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

  663. 

  664.     gNSM.idle();

  665.     gStandalone.engine->idle();

  666. }

  667. 

  668. bool carla_is_engine_running()

  669. {

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

  671. }

  672. 

  673. void carla_set_engine_about_to_close()

  674. {

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

  676.     carla_debug("carla_set_engine_about_to_close()");

  677. 

  678.     gStandalone.engine->setAboutToClose();

  679. }

  680. 

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

  682. {

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

  684. 

  685.     gStandalone.engineCallback    = func;

  686.     gStandalone.engineCallbackPtr = ptr;

  687. 

  688.     if (gStandalone.engine != nullptr)

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

  690. 

  691. //#ifdef WANT_LOGS

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

  693. //#endif

  694. }

  695. 

  696. #ifndef BUILD_BRIDGE

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

  698. {

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

  700. 

  701.     switch (option)

  702.     {

  703.     case CB::ENGINE_OPTION_DEBUG:

  704.         break;

  705. 

  706.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  709.         break;

  710. 

  711.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  714.         break;

  715. 

  716.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  719.         break;

  720. 

  721.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  724.         break;

  725. 

  726.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  729.         break;

  730. 

  731.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  734.         break;

  735. 

  736.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  737.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  739.         break;

  740. 

  741.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  742.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  744.         break;

  745. 

  746.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  749.         break;

  750. 

  751.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  752.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  754.         break;

  755. 

  756.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  757.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  759.         break;

  760. 

  761.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  762.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  763. 

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

  765.             delete[] gStandalone.engineOptions.audioDevice;

  766. 

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

  768.         break;

  769. 

  770.     case CB:: ENGINE_OPTION_NSM_INIT:

  771.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  773. 

  774.         gNSM.announce(value, valueStr);

  775.         break;

  776. 

  777.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  780.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  781. 

  782.         switch (value)

  783.         {

  784.         case CB::PLUGIN_LADSPA:

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

  786.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  788.             break;

  789.         case CB::PLUGIN_DSSI:

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

  791.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  793.             break;

  794.         case CB::PLUGIN_LV2:

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

  796.                 delete[] gStandalone.engineOptions.pathLV2;

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

  798.             break;

  799.         case CB::PLUGIN_VST2:

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

  801.                 delete[] gStandalone.engineOptions.pathVST2;

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

  803.             break;

  804.         case CB::PLUGIN_VST3:

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

  806.                 delete[] gStandalone.engineOptions.pathVST3;

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

  808.             break;

  809.         case CB::PLUGIN_AU:

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

  811.                 delete[] gStandalone.engineOptions.pathAU;

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

  813.             break;

  814.         case CB::PLUGIN_GIG:

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

  816.                 delete[] gStandalone.engineOptions.pathGIG;

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

  818.             break;

  819.         case CB::PLUGIN_SF2:

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

  821.                 delete[] gStandalone.engineOptions.pathSF2;

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

  823.             break;

  824.         case CB::PLUGIN_SFZ:

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

  826.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  828.             break;

  829.         }

  830.         break;

  831. 

  832.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  834. 

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

  836.             delete[] gStandalone.engineOptions.binaryDir;

  837. 

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

  839.         break;

  840. 

  841.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  843. 

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

  845.             delete[] gStandalone.engineOptions.resourceDir;

  846. 

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

  848.         break;

  849. 

  850.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  853.         break;

  854. 

  855.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  858.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  860.         break;

  861.     }

  862. 

  863.     if (gStandalone.engine != nullptr)

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

  865. }

  866. #endif

  867. 

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

  869. {

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

  871. 

  872.     gStandalone.fileCallback    = func;

  873.     gStandalone.fileCallbackPtr = ptr;

  874. 

  875.     if (gStandalone.engine != nullptr)

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

  877. }

  878. 

  879. // -------------------------------------------------------------------------------------------------------------------

  880. 

  881. bool carla_load_file(const char* filename)

  882. {

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

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

  885. 

  886.     if (gStandalone.engine != nullptr)

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

  888. 

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

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

  891.     return false;

  892. }

  893. 

  894. bool carla_load_project(const char* filename)

  895. {

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

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

  898. 

  899.     if (gStandalone.engine != nullptr)

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

  901. 

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

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

  904.     return false;

  905. }

  906. 

  907. bool carla_save_project(const char* filename)

  908. {

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

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

  911. 

  912.     if (gStandalone.engine != nullptr)

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

  914. 

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

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

  917.     return false;

  918. }

  919. 

  920. #ifndef BUILD_BRIDGE

  921. // -------------------------------------------------------------------------------------------------------------------

  922. 

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

  924. {

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

  926. 

  927.     if (gStandalone.engine != nullptr)

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

  929. 

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

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

  932.     return false;

  933. }

  934. 

  935. bool carla_patchbay_disconnect(uint connectionId)

  936. {

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

  938. 

  939.     if (gStandalone.engine != nullptr)

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

  941. 

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

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

  944.     return false;

  945. }

  946. 

  947. bool carla_patchbay_refresh(bool external)

  948. {

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

  950. 

  951.     if (gStandalone.engine != nullptr)

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

  953. 

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

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

  956.     return false;

  957. }

  958. 

  959. // -------------------------------------------------------------------------------------------------------------------

  960. 

  961. void carla_transport_play()

  962. {

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

  964.     carla_debug("carla_transport_play()");

  965. 

  966.     gStandalone.engine->transportPlay();

  967. }

  968. 

  969. void carla_transport_pause()

  970. {

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

  972.     carla_debug("carla_transport_pause()");

  973. 

  974.     gStandalone.engine->transportPause();

  975. }

  976. 

  977. void carla_transport_relocate(uint64_t frame)

  978. {

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

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

  981. 

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

  983. }

  984. 

  985. uint64_t carla_get_current_transport_frame()

  986. {

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

  988. 

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

  990.     return timeInfo.frame;

  991. }

  992. 

  993. const CarlaTransportInfo* carla_get_transport_info()

  994. {

  995.     static CarlaTransportInfo retInfo;

  996. 

  997.     // reset

  998.     retInfo.playing = false;

  999.     retInfo.frame   = 0;

  1000.     retInfo.bar     = 0;

  1001.     retInfo.beat    = 0;

  1002.     retInfo.tick    = 0;

  1003.     retInfo.bpm     = 0.0;

  1004. 

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

  1006. 

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

  1008. 

  1009.     retInfo.playing = timeInfo.playing;

  1010.     retInfo.frame   = timeInfo.frame;

  1011. 

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

  1013.     {

  1014.         retInfo.bar  = timeInfo.bbt.bar;

  1015.         retInfo.beat = timeInfo.bbt.beat;

  1016.         retInfo.tick = timeInfo.bbt.tick;

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

  1018.     }

  1019. 

  1020.     return &retInfo;

  1021. }

  1022. #endif

  1023. 

  1024. // -------------------------------------------------------------------------------------------------------------------

  1025. 

  1026. uint32_t carla_get_current_plugin_count()

  1027. {

  1028.     if (gStandalone.engine != nullptr)

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

  1030. 

  1031.     return 0;

  1032. }

  1033. 

  1034. uint32_t carla_get_max_plugin_number()

  1035. {

  1036.     if (gStandalone.engine != nullptr)

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

  1038. 

  1039.     return 0;

  1040. }

  1041. 

  1042. // -------------------------------------------------------------------------------------------------------------------

  1043. 

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

  1045. {

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

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

  1048. 

  1049.     if (gStandalone.engine != nullptr)

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

  1051. 

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

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

  1054.     return false;

  1055. }

  1056. 

  1057. bool carla_remove_plugin(uint pluginId)

  1058. {

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

  1060. 

  1061.     if (gStandalone.engine != nullptr)

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

  1063. 

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

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

  1066.     return false;

  1067. }

  1068. 

  1069. bool carla_remove_all_plugins()

  1070. {

  1071.     carla_debug("carla_remove_all_plugins()");

  1072. 

  1073.     if (gStandalone.engine != nullptr)

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

  1075. 

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

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

  1078.     return false;

  1079. }

  1080. 

  1081. #ifndef BUILD_BRIDGE

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

  1083. {

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

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

  1086. 

  1087.     if (gStandalone.engine != nullptr)

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

  1089. 

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

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

  1092.     return nullptr;

  1093. }

  1094. 

  1095. bool carla_clone_plugin(uint pluginId)

  1096. {

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

  1098. 

  1099.     if (gStandalone.engine != nullptr)

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

  1101. 

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

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

  1104.     return false;

  1105. }

  1106. 

  1107. bool carla_replace_plugin(uint pluginId)

  1108. {

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

  1110. 

  1111.     if (gStandalone.engine != nullptr)

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

  1113. 

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

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

  1116.     return false;

  1117. }

  1118. 

  1119. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1120. {

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

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

  1123. 

  1124.     if (gStandalone.engine != nullptr)

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

  1126. 

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

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

  1129.     return false;

  1130. }

  1131. #endif

  1132. 

  1133. // -------------------------------------------------------------------------------------------------------------------

  1134. 

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

  1136. {

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

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

  1139. 

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

  1141.     {

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

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

  1144.         return false;

  1145.     }

  1146. 

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

  1148.         return plugin->loadStateFromFile(filename);

  1149. 

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

  1151.     return false;

  1152. }

  1153. 

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

  1155. {

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

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

  1158. 

  1159.     if (gStandalone.engine == nullptr)

  1160.     {

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

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

  1163.         return false;

  1164.     }

  1165. 

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

  1167. 

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

  1169.         return plugin->saveStateToFile(filename);

  1170. 

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

  1172.     return false;

  1173. }

  1174. 

  1175. // -------------------------------------------------------------------------------------------------------------------

  1176. 

  1177. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1178. {

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

  1180. 

  1181.     static CarlaPluginInfo info;

  1182. 

  1183.     // reset

  1184.     info.type             = CB::PLUGIN_NONE;

  1185.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1186.     info.hints            = 0x0;

  1187.     info.optionsAvailable = 0x0;

  1188.     info.optionsEnabled   = 0x0;

  1189.     info.filename         = gNullCharPtr;

  1190.     info.name             = gNullCharPtr;

  1191.     info.iconName         = gNullCharPtr;

  1192.     info.uniqueId         = 0;

  1193. 

  1194.     // cleanup

  1195.     if (info.label != gNullCharPtr)

  1196.     {

  1197.         delete[] info.label;

  1198.         info.label = gNullCharPtr;

  1199.     }

  1200. 

  1201.     if (info.maker != gNullCharPtr)

  1202.     {

  1203.         delete[] info.maker;

  1204.         info.maker = gNullCharPtr;

  1205.     }

  1206. 

  1207.     if (info.copyright != gNullCharPtr)

  1208.     {

  1209.         delete[] info.copyright;

  1210.         info.copyright = gNullCharPtr;

  1211.     }

  1212. 

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

  1214. 

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

  1216.     {

  1217.         char strBufLabel[STR_MAX+1];

  1218.         char strBufMaker[STR_MAX+1];

  1219.         char strBufCopyright[STR_MAX+1];

  1220. 

  1221.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1222.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1223.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1224. 

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

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

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

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

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

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

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

  1232. 

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

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

  1235. 

  1236.         plugin->getLabel(strBufLabel);

  1237.         info.label = carla_strdup_safe(strBufLabel);

  1238. 

  1239.         plugin->getMaker(strBufMaker);

  1240.         info.maker = carla_strdup_safe(strBufMaker);

  1241. 

  1242.         plugin->getCopyright(strBufCopyright);

  1243.         info.copyright = carla_strdup_safe(strBufCopyright);

  1244. 

  1245.         checkStringPtr(info.filename);

  1246.         checkStringPtr(info.name);

  1247.         checkStringPtr(info.iconName);

  1248.         checkStringPtr(info.label);

  1249.         checkStringPtr(info.maker);

  1250.         checkStringPtr(info.copyright);

  1251. 

  1252.         return &info;

  1253.     }

  1254. 

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

  1256.     return &info;

  1257. }

  1258. 

  1259. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1260. {

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

  1262. 

  1263.     static CarlaPortCountInfo info;

  1264. 

  1265.     // reset

  1266.     info.ins   = 0;

  1267.     info.outs  = 0;

  1268. 

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

  1270. 

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

  1272.     {

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

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

  1275.         return &info;

  1276.     }

  1277. 

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

  1279.     return &info;

  1280. }

  1281. 

  1282. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1283. {

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

  1285. 

  1286.     static CarlaPortCountInfo info;

  1287. 

  1288.     // reset

  1289.     info.ins   = 0;

  1290.     info.outs  = 0;

  1291. 

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

  1293. 

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

  1295.     {

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

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

  1298.         return &info;

  1299.     }

  1300. 

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

  1302.     return &info;

  1303. }

  1304. 

  1305. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1306. {

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

  1308. 

  1309.     static CarlaPortCountInfo info;

  1310. 

  1311.     // reset

  1312.     info.ins   = 0;

  1313.     info.outs  = 0;

  1314. 

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

  1316. 

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

  1318.     {

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

  1320.         return &info;

  1321.     }

  1322. 

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

  1324.     return &info;

  1325. }

  1326. 

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

  1328. {

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

  1330. 

  1331.     static CarlaParameterInfo info;

  1332. 

  1333.     // reset

  1334.     info.scalePointCount = 0;

  1335. 

  1336.     // cleanup

  1337.     if (info.name != gNullCharPtr)

  1338.     {

  1339.         delete[] info.name;

  1340.         info.name = gNullCharPtr;

  1341.     }

  1342. 

  1343.     if (info.symbol != gNullCharPtr)

  1344.     {

  1345.         delete[] info.symbol;

  1346.         info.symbol = gNullCharPtr;

  1347.     }

  1348. 

  1349.     if (info.unit != gNullCharPtr)

  1350.     {

  1351.         delete[] info.unit;

  1352.         info.unit = gNullCharPtr;

  1353.     }

  1354. 

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

  1356. 

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

  1358.     {

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

  1360.         {

  1361.             char strBufName[STR_MAX+1];

  1362.             char strBufSymbol[STR_MAX+1];

  1363.             char strBufUnit[STR_MAX+1];

  1364. 

  1365.             carla_zeroChar(strBufName, STR_MAX+1);

  1366.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1367.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1368. 

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

  1370. 

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

  1372.             info.name = carla_strdup_safe(strBufName);

  1373. 

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

  1375.             info.symbol = carla_strdup_safe(strBufSymbol);

  1376. 

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

  1378.             info.unit = carla_strdup_safe(strBufUnit);

  1379. 

  1380.             checkStringPtr(info.name);

  1381.             checkStringPtr(info.symbol);

  1382.             checkStringPtr(info.unit);

  1383.         }

  1384.         else

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

  1386. 

  1387.         return &info;

  1388.     }

  1389. 

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

  1391.     return &info;

  1392. }

  1393. 

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

  1395. {

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

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

  1398. 

  1399.     static CarlaScalePointInfo info;

  1400. 

  1401.     // reset

  1402.     info.value = 0.0f;

  1403. 

  1404.     // cleanup

  1405.     if (info.label != gNullCharPtr)

  1406.     {

  1407.         delete[] info.label;

  1408.         info.label = gNullCharPtr;

  1409.     }

  1410. 

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

  1412. 

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

  1414.     {

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

  1416.         {

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

  1418.             {

  1419.                 char strBufLabel[STR_MAX+1];

  1420.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1421. 

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

  1423. 

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

  1425.                 info.label = carla_strdup_safe(strBufLabel);

  1426.                 checkStringPtr(info.label);

  1427.             }

  1428.             else

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

  1430.         }

  1431.         else

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

  1433. 

  1434.         return &info;

  1435.     }

  1436. 

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

  1438.     return &info;

  1439. }

  1440. 

  1441. // -------------------------------------------------------------------------------------------------------------------

  1442. 

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

  1444. {

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

  1446. 

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

  1448. 

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

  1450. 

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

  1452.     {

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

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

  1455. 

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

  1457.         return &fallbackParameterData;

  1458.     }

  1459. 

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

  1461.     return &fallbackParameterData;

  1462. }

  1463. 

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

  1465. {

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

  1467. 

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

  1469. 

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

  1471. 

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

  1473.     {

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

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

  1476. 

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

  1478.         return &fallbackParamRanges;

  1479.     }

  1480. 

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

  1482.     return &fallbackParamRanges;

  1483. }

  1484. 

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

  1486. {

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

  1488. 

  1489.     static MidiProgramData midiProgData;

  1490. 

  1491.     // reset

  1492.     midiProgData.bank    = 0;

  1493.     midiProgData.program = 0;

  1494.     midiProgData.name    = gNullCharPtr;

  1495. 

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

  1497. 

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

  1499.     {

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

  1501.         {

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

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

  1504.             checkStringPtr(midiProgData.name);

  1505.             return &midiProgData;

  1506.         }

  1507. 

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

  1509.         return &midiProgData;

  1510.     }

  1511. 

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

  1513.     return &midiProgData;

  1514. }

  1515. 

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

  1517. {

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

  1519. 

  1520.     static CustomData customData;

  1521. 

  1522.     // reset

  1523.     customData.type  = gNullCharPtr;

  1524.     customData.key   = gNullCharPtr;

  1525.     customData.value = gNullCharPtr;

  1526. 

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

  1528. 

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

  1530.     {

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

  1532.         {

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

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

  1535.             checkStringPtr(customData.type);

  1536.             checkStringPtr(customData.key);

  1537.             checkStringPtr(customData.value);

  1538.             return &customData;

  1539.         }

  1540. 

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

  1542.         return &customData;

  1543.     }

  1544. 

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

  1546.     return &customData;

  1547. }

  1548. 

  1549. const char* carla_get_chunk_data(uint pluginId)

  1550. {

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

  1552. 

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

  1554. 

  1555.     static CarlaString chunkData;

  1556. 

  1557.     // cleanup

  1558.     chunkData.clear();

  1559. 

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

  1561.     {

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

  1563.         {

  1564.             void* data = nullptr;

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

  1566. 

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

  1568.             {

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

  1570.                 return chunkData;

  1571.             }

  1572.             else

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

  1574.         }

  1575.         else

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

  1577. 

  1578.         return nullptr;

  1579.     }

  1580. 

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

  1582.     return nullptr;

  1583. }

  1584. 

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

  1586. 

  1587. uint32_t carla_get_parameter_count(uint pluginId)

  1588. {

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

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

  1591. 

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

  1593.         return plugin->getParameterCount();

  1594. 

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

  1596.     return 0;

  1597. }

  1598. 

  1599. uint32_t carla_get_program_count(uint pluginId)

  1600. {

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

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

  1603. 

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

  1605.         return plugin->getProgramCount();

  1606. 

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

  1608.     return 0;

  1609. }

  1610. 

  1611. uint32_t carla_get_midi_program_count(uint pluginId)

  1612. {

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

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

  1615. 

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

  1617.         return plugin->getMidiProgramCount();

  1618. 

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

  1620.     return 0;

  1621. }

  1622. 

  1623. uint32_t carla_get_custom_data_count(uint pluginId)

  1624. {

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

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

  1627. 

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

  1629.         return plugin->getCustomDataCount();

  1630. 

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

  1632.     return 0;

  1633. }

  1634. 

  1635. // -------------------------------------------------------------------------------------------------------------------

  1636. 

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

  1638. {

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

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

  1641. 

  1642.     static char textBuf[STR_MAX+1];

  1643. 

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

  1645.     {

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

  1647.         {

  1648.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1650.             return textBuf;

  1651.         }

  1652. 

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

  1654.         return nullptr;

  1655.     }

  1656. 

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

  1658.     return nullptr;

  1659. }

  1660. 

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

  1662. {

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

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

  1665. 

  1666.     static char programName[STR_MAX+1];

  1667. 

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

  1669.     {

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

  1671.         {

  1672.             carla_zeroChar(programName, STR_MAX+1);

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

  1674.             return programName;

  1675.         }

  1676. 

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

  1678.         return nullptr;

  1679.     }

  1680. 

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

  1682.     return nullptr;

  1683. }

  1684. 

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

  1686. {

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

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

  1689. 

  1690.     static char midiProgramName[STR_MAX+1];

  1691. 

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

  1693.     {

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

  1695.         {

  1696.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1698.             return midiProgramName;

  1699.         }

  1700. 

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

  1702.         return nullptr;

  1703.     }

  1704. 

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

  1706.     return nullptr;

  1707. }

  1708. 

  1709. const char* carla_get_real_plugin_name(uint pluginId)

  1710. {

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

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

  1713. 

  1714.     static char realPluginName[STR_MAX+1];

  1715. 

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

  1717.     {

  1718.         carla_zeroChar(realPluginName, STR_MAX+1);

  1719.         plugin->getRealName(realPluginName);

  1720.         return realPluginName;

  1721.     }

  1722. 

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

  1724.     return nullptr;

  1725. }

  1726. 

  1727. // -------------------------------------------------------------------------------------------------------------------

  1728. 

  1729. int32_t carla_get_current_program_index(uint pluginId)

  1730. {

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

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

  1733. 

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

  1735.         return plugin->getCurrentProgram();

  1736. 

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

  1738.     return -1;

  1739. }

  1740. 

  1741. int32_t carla_get_current_midi_program_index(uint pluginId)

  1742. {

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

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

  1745. 

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

  1747.         return plugin->getCurrentMidiProgram();

  1748. 

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

  1750.     return -1;

  1751. }

  1752. 

  1753. // -------------------------------------------------------------------------------------------------------------------

  1754. 

  1755. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1756. {

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

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

  1759. 

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

  1761.     {

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

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

  1764. 

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

  1766.         return 0.0f;

  1767.     }

  1768. 

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

  1770.     return 0.0f;

  1771. }

  1772. 

  1773. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1774. {

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

  1776. 

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

  1778.     {

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

  1780.             return plugin->getParameterValue(parameterId);

  1781. 

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

  1783.         return 0.0f;

  1784.     }

  1785. 

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

  1787.     return 0.0f;

  1788. }

  1789. 

  1790. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1791. {

  1792. #ifdef BUILD_BRIDGE

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

  1794. #else

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

  1796. #endif

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

  1798. 

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

  1800.         return plugin->getInternalParameterValue(parameterId);

  1801. 

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

  1803.     return 0.0f;

  1804. }

  1805. 

  1806. // -------------------------------------------------------------------------------------------------------------------

  1807. 

  1808. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1809. {

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

  1811. 

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

  1813. }

  1814. 

  1815. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1816. {

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

  1818. 

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

  1820. }

  1821. 

  1822. // -------------------------------------------------------------------------------------------------------------------

  1823. 

  1824. void carla_set_active(uint pluginId, bool onOff)

  1825. {

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

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

  1828. 

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

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

  1831. 

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

  1833. }

  1834. 

  1835. #ifndef BUILD_BRIDGE

  1836. void carla_set_drywet(uint pluginId, float value)

  1837. {

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

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

  1840. 

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

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

  1843. 

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

  1845. }

  1846. 

  1847. void carla_set_volume(uint pluginId, float value)

  1848. {

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

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

  1851. 

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

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

  1854. 

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

  1856. }

  1857. 

  1858. void carla_set_balance_left(uint pluginId, float value)

  1859. {

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

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

  1862. 

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

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

  1865. 

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

  1867. }

  1868. 

  1869. void carla_set_balance_right(uint pluginId, float value)

  1870. {

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

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

  1873. 

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

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

  1876. 

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

  1878. }

  1879. 

  1880. void carla_set_panning(uint pluginId, float value)

  1881. {

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

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

  1884. 

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

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

  1887. 

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

  1889. }

  1890. 

  1891. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1892. {

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

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

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

  1896. 

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

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

  1899. 

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

  1901. }

  1902. 

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

  1904. {

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

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

  1907. 

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

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

  1910. 

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

  1912. }

  1913. #endif

  1914. 

  1915. // -------------------------------------------------------------------------------------------------------------------

  1916. 

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

  1918. {

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

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

  1921. 

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

  1923.     {

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

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

  1926. 

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

  1928.         return;

  1929.     }

  1930. 

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

  1932. }

  1933. 

  1934. #ifndef BUILD_BRIDGE

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

  1936. {

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

  1938.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  1940. 

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

  1942.     {

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

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

  1945. 

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

  1947.         return;

  1948.     }

  1949. 

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

  1951. }

  1952. 

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

  1954. {

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

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

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

  1958. 

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

  1960.     {

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

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

  1963. 

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

  1965.         return;

  1966.     }

  1967. 

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

  1969. }

  1970. #endif

  1971. 

  1972. // -------------------------------------------------------------------------------------------------------------------

  1973. 

  1974. void carla_set_program(uint pluginId, uint32_t programId)

  1975. {

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

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

  1978. 

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

  1980.     {

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

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

  1983. 

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

  1985.         return;

  1986.     }

  1987. 

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

  1989. }

  1990. 

  1991. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1992. {

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

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

  1995. 

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

  1997.     {

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

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

  2000. 

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

  2002.         return;

  2003.     }

  2004. 

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

  2006. }

  2007. 

  2008. // -------------------------------------------------------------------------------------------------------------------

  2009. 

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

  2011. {

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

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

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

  2015.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2017. 

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

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

  2020. 

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

  2022. }

  2023. 

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

  2025. {

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

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

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

  2029. 

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

  2031.     {

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

  2033.         {

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

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

  2036.         }

  2037. 

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

  2039.         return;

  2040.     }

  2041. 

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

  2043. }

  2044. 

  2045. // -------------------------------------------------------------------------------------------------------------------

  2046. 

  2047. void carla_prepare_for_save(uint pluginId)

  2048. {

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

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

  2051. 

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

  2053.         return plugin->prepareForSave();

  2054. 

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

  2056. }

  2057. 

  2058. void carla_reset_parameters(uint pluginId)

  2059. {

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

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

  2062. 

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

  2064.         return plugin->resetParameters();

  2065. 

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

  2067. }

  2068. 

  2069. void carla_randomize_parameters(uint pluginId)

  2070. {

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

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

  2073. 

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

  2075.         return plugin->randomizeParameters();

  2076. 

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

  2078. }

  2079. 

  2080. #ifndef BUILD_BRIDGE

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

  2082. {

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

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

  2085. 

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

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

  2088. 

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

  2090. }

  2091. #endif

  2092. 

  2093. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2094. {

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

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

  2097. 

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

  2099.         return plugin->showCustomUI(yesNo);

  2100. 

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

  2102. }

  2103. 

  2104. // -------------------------------------------------------------------------------------------------------------------

  2105. 

  2106. uint32_t carla_get_buffer_size()

  2107. {

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

  2109.     carla_debug("carla_get_buffer_size()");

  2110. 

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

  2112. }

  2113. 

  2114. double carla_get_sample_rate()

  2115. {

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

  2117.     carla_debug("carla_get_sample_rate()");

  2118. 

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

  2120. }

  2121. 

  2122. // -------------------------------------------------------------------------------------------------------------------

  2123. 

  2124. const char* carla_get_last_error()

  2125. {

  2126.     carla_debug("carla_get_last_error()");

  2127. 

  2128.     if (gStandalone.engine != nullptr)

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

  2130. 

  2131.     return gStandalone.lastError;

  2132. }

  2133. 

  2134. const char* carla_get_host_osc_url_tcp()

  2135. {

  2136.     carla_debug("carla_get_host_osc_url_tcp()");

  2137. 

  2138.     if (gStandalone.engine == nullptr)

  2139.     {

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

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

  2142.         return nullptr;

  2143.     }

  2144. 

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

  2146. }

  2147. 

  2148. const char* carla_get_host_osc_url_udp()

  2149. {

  2150.     carla_debug("carla_get_host_osc_url_udp()");

  2151. 

  2152.     if (gStandalone.engine == nullptr)

  2153.     {

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

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

  2156.         return nullptr;

  2157.     }

  2158. 

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

  2160. }

  2161. 

  2162. // -------------------------------------------------------------------------------------------------------------------

  2163. 

  2164. #include "CarlaPluginUI.cpp"

  2165. #include "CarlaDssiUtils.cpp"

  2166. #include "CarlaPipeUtils.cpp"

  2167. #include "CarlaStateUtils.cpp"

  2168. #include "CarlaJuceEvents.cpp"

  2169. 

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