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

2175 lines
77KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. 

  24. #include "CarlaEngine.hpp"

  25. #include "CarlaPlugin.hpp"

  26. 

  27. #include "CarlaBackendUtils.hpp"

  28. #include "CarlaBase64Utils.hpp"

  29. #include "CarlaOscUtils.hpp"

  30. #include "CarlaThread.hpp"

  31. 

  32. #include "juce_audio_formats.h"

  33. 

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

  35. # include "juce_gui_basics.h"

  36. #else

  37. namespace juce {

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

  39. } // namespace juce

  40. #endif

  41. 

  42. namespace CB = CarlaBackend;

  43. using CB::EngineOptions;

  44. 

  45. // -------------------------------------------------------------------------------------------------------------------

  46. // Single, standalone engine

  47. 

  48. struct CarlaBackendStandalone {

  49.     CarlaEngine*       engine;

  50.     EngineCallbackFunc engineCallback;

  51.     void*              engineCallbackPtr;

  52.     EngineOptions      engineOptions;

  53. 

  54.     FileCallbackFunc fileCallback;

  55.     void*            fileCallbackPtr;

  56. 

  57.     CarlaString lastError;

  58. 

  59.     CarlaBackendStandalone()

  60.         : engine(nullptr),

  61.           engineCallback(nullptr),

  62.           engineCallbackPtr(nullptr),

  63.           engineOptions(),

  64.           fileCallback(nullptr),

  65.           fileCallbackPtr(nullptr),

  66.           lastError()

  67.     {

  68. #ifdef BUILD_BRIDGE

  69.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  70.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  71.         engineOptions.forceStereo         = false;

  72.         engineOptions.preferPluginBridges = false;

  73.         engineOptions.preferUiBridges     = false;

  74. 

  75.         using juce::File;

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

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

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

  79. #endif

  80.     }

  81. 

  82.     ~CarlaBackendStandalone()

  83.     {

  84.         CARLA_SAFE_ASSERT(engine == nullptr);

  85.     }

  86. 

  87.     CARLA_PREVENT_HEAP_ALLOCATION

  88.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  89. };

  90. 

  91. static CarlaBackendStandalone gStandalone;

  92. 

  93. // -------------------------------------------------------------------------------------------------------------------

  94. // NSM support

  95. 

  96. #define NSM_API_VERSION_MAJOR 1

  97. #define NSM_API_VERSION_MINOR 2

  98. 

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

  100. #define NSM_CLIENT_FEATURES ":switch:"

  101. 

  102. class CarlaNSM

  103. {

  104. public:

  105.     CarlaNSM() noexcept

  106.         : fOscServer(nullptr),

  107.           fClientId(),

  108.           fProjectPath(),

  109.           fHasBroadcast(false),

  110.           fHasShowHideUI(false) {}

  111. 

  112.     ~CarlaNSM()

  113.     {

  114.         if (fOscServer != nullptr)

  115.         {

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

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

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

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

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

  121.             lo_server_free(fOscServer);

  122.             fOscServer = nullptr;

  123.         }

  124.     }

  125. 

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

  127.     {

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

  129. 

  130.         if (NSM_URL == nullptr)

  131.             return;

  132. 

  133.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  134.         CARLA_SAFE_ASSERT_RETURN(addr != nullptr,);

  135. 

  136.         const int proto = lo_address_get_protocol(addr);

  137. 

  138.         if (fOscServer == nullptr)

  139.         {

  140.             // create new OSC server

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

  142. 

  143.             // register message handlers and start OSC thread

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

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

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

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

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

  149.             // /nsm/client/session_is_loaded

  150.         }

  151. 

  152. #ifndef BUILD_ANSI_TEST

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

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

  155. #endif

  156. 

  157.         lo_address_free(addr);

  158.     }

  159. 

  160.     void idle() noexcept

  161.     {

  162.         if (fOscServer == nullptr)

  163.             return;

  164. 

  165.         for (;;)

  166.         {

  167.             try {

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

  169.                     break;

  170.             } CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  171.         }

  172.     }

  173. 

  174. protected:

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

  176.     {

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

  178. 

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

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

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

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

  183. 

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

  185. 

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

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

  188. 

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

  190. 

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

  192. 

  193.         return 0;

  194. 

  195. #ifndef DEBUG

  196.         // unused

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

  198. #endif

  199.     }

  200. 

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

  202.     {

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

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

  205. 

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

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

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

  209. 

  210.         if (! carla_is_engine_running())

  211.         {

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

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

  214. 

  215.             carla_engine_init("JACK", clientId);

  216.         }

  217.         else

  218.         {

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

  220. 

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

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

  223.         }

  224. 

  225.         fClientId = clientId;

  226. 

  227.         fProjectPath  = projectPath;

  228.         fProjectPath += ".carxp";

  229. 

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

  231. 

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

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

  234. 

  235. #ifndef BUILD_ANSI_TEST

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

  237. #endif

  238. 

  239. #if 0

  240.         if (fHasBroadcast)

  241.         {

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

  243. 

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

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

  246. 

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

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

  249. 

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

  251. 

  252.             std::free(url);

  253. 

  254.             carla_stdout("Broadcast sent!");

  255.         }

  256.         else

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

  258. #endif

  259. 

  260.         return 0;

  261. 

  262. #ifndef DEBUG

  263.         // unused

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

  265. #endif

  266.     }

  267. 

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

  269.     {

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

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

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

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

  274. 

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

  276. 

  277. #ifndef BUILD_ANSI_TEST

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

  279. #endif

  280. 

  281.         return 0;

  282. 

  283. #ifndef DEBUG

  284.         // unused

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

  286. #endif

  287.     }

  288. 

  289. #if 0

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

  291.     {

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

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

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

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

  296. 

  297. #ifndef BUILD_ANSI_TEST

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

  299. #endif

  300. 

  301.         return 0;

  302.     }

  303. #endif

  304. 

  305. private:

  306.     lo_server fOscServer;

  307. 

  308.     CarlaString fClientId;

  309.     CarlaString fProjectPath;

  310. 

  311.     bool fHasBroadcast;

  312.     bool fHasShowHideUI;

  313. 

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

  315. 

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

  317.     {

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

  319.     }

  320. 

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

  322.     {

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

  324.     }

  325. 

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

  327.     {

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

  329.     }

  330. 

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

  332.     {

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

  334.     }

  335. 

  336. #if 0

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

  338.     {

  339.         return handlePtr->handleShowHideGui(true);

  340.     }

  341. 

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

  343.     {

  344.         return handlePtr->handleShowHideGui(false);

  345.     }

  346. #endif

  347. 

  348.     #undef handlePtr

  349. 

  350.     CARLA_PREVENT_HEAP_ALLOCATION

  351.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  352. };

  353. 

  354. static CarlaNSM gNSM;

  355. 

  356. // -------------------------------------------------------------------------------------------------------------------

  357. // API

  358. 

  359. #define CARLA_COMMON_NEED_CHECKSTRINGPTR

  360. #include "CarlaHostCommon.cpp"

  361. 

  362. // -------------------------------------------------------------------------------------------------------------------

  363. 

  364. uint carla_get_engine_driver_count()

  365. {

  366.     carla_debug("carla_get_engine_driver_count()");

  367. 

  368.     return CarlaEngine::getDriverCount();

  369. }

  370. 

  371. const char* carla_get_engine_driver_name(uint index)

  372. {

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

  374. 

  375.     return CarlaEngine::getDriverName(index);

  376. }

  377. 

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

  379. {

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

  381. 

  382.     return CarlaEngine::getDriverDeviceNames(index);

  383. }

  384. 

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

  386. {

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

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

  389. 

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

  391.     {

  392.         static EngineDriverDeviceInfo devInfo;

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

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

  395. 

  396.         devInfo.hints       = ret->hints;

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

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

  399.         return &devInfo;

  400.     }

  401. 

  402.     return nullptr;

  403. }

  404. 

  405. // -------------------------------------------------------------------------------------------------------------------

  406. 

  407. const CarlaEngine* carla_get_engine()

  408. {

  409.     carla_debug("carla_get_engine()");

  410. 

  411.     return gStandalone.engine;

  412. }

  413. 

  414. // -------------------------------------------------------------------------------------------------------------------

  415. 

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

  417. {

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

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

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

  421. 

  422.     if (gStandalone.engine != nullptr)

  423.     {

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

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

  426.         return false;

  427.     }

  428. 

  429. #ifdef CARLA_OS_WIN

  430.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  431. #endif

  432. 

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

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

  435.     {

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

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

  438.     }

  439. 

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

  441. 

  442.     if (gStandalone.engine == nullptr)

  443.     {

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

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

  446.         return false;

  447.     }

  448. 

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

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

  451. 

  452. #ifdef BUILD_BRIDGE

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

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

  455. #else

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

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

  458. #endif

  459. 

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

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

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

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

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

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

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

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

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

  469. 

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

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

  472. 

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

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

  475. 

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

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

  478. 

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

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

  481. 

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

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

  484. 

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

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

  487. 

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

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

  490. 

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

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

  493. 

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

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

  496. 

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

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

  499. 

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

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

  502. 

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

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

  505. 

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

  507. 

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

  509.     {

  510.         char strBuf[STR_MAX+1];

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

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

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

  514.     }

  515.     else

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

  517. 

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

  519.     {

  520. #ifndef BUILD_BRIDGE

  521.         juce::initialiseJuce_GUI();

  522. #endif

  523.         gStandalone.lastError = "No error";

  524.         return true;

  525.     }

  526.     else

  527.     {

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

  529.         delete gStandalone.engine;

  530.         gStandalone.engine = nullptr;

  531.         return false;

  532.     }

  533. }

  534. 

  535. #ifdef BUILD_BRIDGE

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

  537. {

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

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

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

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

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

  543. 

  544.     if (gStandalone.engine != nullptr)

  545.     {

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

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

  548.         return false;

  549.     }

  550. 

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

  552. 

  553.     if (gStandalone.engine == nullptr)

  554.     {

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

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

  557.         return false;

  558.     }

  559. 

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

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

  562. 

  563.     // forced options for bridge mode

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

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

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

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

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

  569. 

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

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

  572. 

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

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

  575. 

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

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

  578. 

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

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

  581. 

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

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

  584. 

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

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

  587. 

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

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

  590. 

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

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

  593. 

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

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

  596. 

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

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

  599. 

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

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

  602. 

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

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

  605. 

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

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

  608. 

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

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

  611. 

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

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

  614. 

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

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

  617. 

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

  619.     {

  620.         gStandalone.lastError = "No error";

  621.         return true;

  622.     }

  623.     else

  624.     {

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

  626.         delete gStandalone.engine;

  627.         gStandalone.engine = nullptr;

  628.         return false;

  629.     }

  630. }

  631. #endif

  632. 

  633. bool carla_engine_close()

  634. {

  635.     carla_debug("carla_engine_close()");

  636. 

  637.     if (gStandalone.engine == nullptr)

  638.     {

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

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

  641.         return false;

  642.     }

  643. 

  644.     gStandalone.engine->setAboutToClose();

  645.     gStandalone.engine->removeAllPlugins();

  646. 

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

  648. 

  649.     if (! closed)

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

  651. 

  652. #ifndef BUILD_BRIDGE

  653.     juce::shutdownJuce_GUI();

  654. #endif

  655.     delete gStandalone.engine;

  656.     gStandalone.engine = nullptr;

  657. 

  658.     return closed;

  659. }

  660. 

  661. void carla_engine_idle()

  662. {

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

  664. 

  665.     gNSM.idle();

  666.     gStandalone.engine->idle();

  667. }

  668. 

  669. bool carla_is_engine_running()

  670. {

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

  672. }

  673. 

  674. void carla_set_engine_about_to_close()

  675. {

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

  677.     carla_debug("carla_set_engine_about_to_close()");

  678. 

  679.     gStandalone.engine->setAboutToClose();

  680. }

  681. 

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

  683. {

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

  685. 

  686.     gStandalone.engineCallback    = func;

  687.     gStandalone.engineCallbackPtr = ptr;

  688. 

  689.     if (gStandalone.engine != nullptr)

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

  691. 

  692. //#ifdef WANT_LOGS

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

  694. //#endif

  695. }

  696. 

  697. #ifndef BUILD_BRIDGE

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

  699. {

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

  701. 

  702.     switch (option)

  703.     {

  704.     case CB::ENGINE_OPTION_DEBUG:

  705.         break;

  706. 

  707.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  710.         break;

  711. 

  712.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  715.         break;

  716. 

  717.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  720.         break;

  721. 

  722.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  725.         break;

  726. 

  727.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  730.         break;

  731. 

  732.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  735.         break;

  736. 

  737.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  738.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  740.         break;

  741. 

  742.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  743.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  745.         break;

  746. 

  747.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  750.         break;

  751. 

  752.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  753.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  755.         break;

  756. 

  757.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  758.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  760.         break;

  761. 

  762.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  763.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  764. 

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

  766.             delete[] gStandalone.engineOptions.audioDevice;

  767. 

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

  769.         break;

  770. 

  771.     case CB:: ENGINE_OPTION_NSM_INIT:

  772.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  774. 

  775.         // this is only called if we're not a plugin, so it's safe

  776.         CarlaThread::setCurrentThreadName("Carla");

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

  778. 

  779.         gNSM.announce(value, valueStr);

  780.         break;

  781. 

  782.     case CB::ENGINE_OPTION_PLUGIN_PATH:

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

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

  785.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  786. 

  787.         switch (value)

  788.         {

  789.         case CB::PLUGIN_LADSPA:

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

  791.                 delete[] gStandalone.engineOptions.pathLADSPA;

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

  793.             break;

  794.         case CB::PLUGIN_DSSI:

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

  796.                 delete[] gStandalone.engineOptions.pathDSSI;

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

  798.             break;

  799.         case CB::PLUGIN_LV2:

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

  801.                 delete[] gStandalone.engineOptions.pathLV2;

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

  803.             break;

  804.         case CB::PLUGIN_VST:

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

  806.                 delete[] gStandalone.engineOptions.pathVST;

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

  808.             break;

  809.         case CB::PLUGIN_VST3:

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

  811.                 delete[] gStandalone.engineOptions.pathVST3;

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

  813.             break;

  814.         case CB::PLUGIN_AU:

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

  816.                 delete[] gStandalone.engineOptions.pathAU;

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

  818.             break;

  819.         case CB::PLUGIN_GIG:

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

  821.                 delete[] gStandalone.engineOptions.pathGIG;

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

  823.             break;

  824.         case CB::PLUGIN_SF2:

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

  826.                 delete[] gStandalone.engineOptions.pathSF2;

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

  828.             break;

  829.         case CB::PLUGIN_SFZ:

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

  831.                 delete[] gStandalone.engineOptions.pathSFZ;

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

  833.             break;

  834.         }

  835.         break;

  836. 

  837.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  839. 

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

  841.             delete[] gStandalone.engineOptions.binaryDir;

  842. 

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

  844.         break;

  845. 

  846.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  848. 

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

  850.             delete[] gStandalone.engineOptions.resourceDir;

  851. 

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

  853.         break;

  854. 

  855.     case CB::ENGINE_OPTION_PREVENT_BAD_BEHAVIOUR:

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

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

  858.         break;

  859. 

  860.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  863.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  865.         break;

  866.     }

  867. 

  868.     if (gStandalone.engine != nullptr)

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

  870. }

  871. #endif

  872. 

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

  874. {

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

  876. 

  877.     gStandalone.fileCallback    = func;

  878.     gStandalone.fileCallbackPtr = ptr;

  879. 

  880.     if (gStandalone.engine != nullptr)

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

  882. }

  883. 

  884. // -------------------------------------------------------------------------------------------------------------------

  885. 

  886. bool carla_load_file(const char* filename)

  887. {

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

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

  890. 

  891.     if (gStandalone.engine != nullptr)

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

  893. 

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

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

  896.     return false;

  897. }

  898. 

  899. bool carla_load_project(const char* filename)

  900. {

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

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

  903. 

  904.     if (gStandalone.engine != nullptr)

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

  906. 

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

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

  909.     return false;

  910. }

  911. 

  912. bool carla_save_project(const char* filename)

  913. {

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

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

  916. 

  917.     if (gStandalone.engine != nullptr)

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

  919. 

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

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

  922.     return false;

  923. }

  924. 

  925. #ifndef BUILD_BRIDGE

  926. // -------------------------------------------------------------------------------------------------------------------

  927. 

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

  929. {

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

  931. 

  932.     if (gStandalone.engine != nullptr)

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

  934. 

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

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

  937.     return false;

  938. }

  939. 

  940. bool carla_patchbay_disconnect(uint connectionId)

  941. {

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

  943. 

  944.     if (gStandalone.engine != nullptr)

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

  946. 

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

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

  949.     return false;

  950. }

  951. 

  952. bool carla_patchbay_refresh(bool external)

  953. {

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

  955. 

  956.     if (gStandalone.engine != nullptr)

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

  958. 

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

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

  961.     return false;

  962. }

  963. 

  964. // -------------------------------------------------------------------------------------------------------------------

  965. 

  966. void carla_transport_play()

  967. {

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

  969.     carla_debug("carla_transport_play()");

  970. 

  971.     gStandalone.engine->transportPlay();

  972. }

  973. 

  974. void carla_transport_pause()

  975. {

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

  977.     carla_debug("carla_transport_pause()");

  978. 

  979.     gStandalone.engine->transportPause();

  980. }

  981. 

  982. void carla_transport_relocate(uint64_t frame)

  983. {

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

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

  986. 

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

  988. }

  989. 

  990. uint64_t carla_get_current_transport_frame()

  991. {

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

  993. 

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

  995.     return timeInfo.frame;

  996. }

  997. 

  998. const CarlaTransportInfo* carla_get_transport_info()

  999. {

  1000.     static CarlaTransportInfo retInfo;

  1001. 

  1002.     // reset

  1003.     retInfo.playing = false;

  1004.     retInfo.frame   = 0;

  1005.     retInfo.bar     = 0;

  1006.     retInfo.beat    = 0;

  1007.     retInfo.tick    = 0;

  1008.     retInfo.bpm     = 0.0;

  1009. 

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

  1011. 

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

  1013. 

  1014.     retInfo.playing = timeInfo.playing;

  1015.     retInfo.frame   = timeInfo.frame;

  1016. 

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

  1018.     {

  1019.         retInfo.bar  = timeInfo.bbt.bar;

  1020.         retInfo.beat = timeInfo.bbt.beat;

  1021.         retInfo.tick = timeInfo.bbt.tick;

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

  1023.     }

  1024. 

  1025.     return &retInfo;

  1026. }

  1027. #endif

  1028. 

  1029. // -------------------------------------------------------------------------------------------------------------------

  1030. 

  1031. uint32_t carla_get_current_plugin_count()

  1032. {

  1033.     if (gStandalone.engine != nullptr)

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

  1035. 

  1036.     return 0;

  1037. }

  1038. 

  1039. uint32_t carla_get_max_plugin_number()

  1040. {

  1041.     if (gStandalone.engine != nullptr)

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

  1043. 

  1044.     return 0;

  1045. }

  1046. 

  1047. // -------------------------------------------------------------------------------------------------------------------

  1048. 

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

  1050. {

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

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

  1053. 

  1054.     if (gStandalone.engine != nullptr)

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

  1056. 

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

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

  1059.     return false;

  1060. }

  1061. 

  1062. bool carla_remove_plugin(uint pluginId)

  1063. {

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

  1065. 

  1066.     if (gStandalone.engine != nullptr)

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

  1068. 

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

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

  1071.     return false;

  1072. }

  1073. 

  1074. bool carla_remove_all_plugins()

  1075. {

  1076.     carla_debug("carla_remove_all_plugins()");

  1077. 

  1078.     if (gStandalone.engine != nullptr)

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

  1080. 

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

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

  1083.     return false;

  1084. }

  1085. 

  1086. #ifndef BUILD_BRIDGE

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

  1088. {

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

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

  1091. 

  1092.     if (gStandalone.engine != nullptr)

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

  1094. 

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

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

  1097.     return nullptr;

  1098. }

  1099. 

  1100. bool carla_clone_plugin(uint pluginId)

  1101. {

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

  1103. 

  1104.     if (gStandalone.engine != nullptr)

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

  1106. 

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

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

  1109.     return false;

  1110. }

  1111. 

  1112. bool carla_replace_plugin(uint pluginId)

  1113. {

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

  1115. 

  1116.     if (gStandalone.engine != nullptr)

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

  1118. 

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

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

  1121.     return false;

  1122. }

  1123. 

  1124. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1125. {

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

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

  1128. 

  1129.     if (gStandalone.engine != nullptr)

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

  1131. 

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

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

  1134.     return false;

  1135. }

  1136. #endif

  1137. 

  1138. // -------------------------------------------------------------------------------------------------------------------

  1139. 

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

  1141. {

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

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

  1144. 

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

  1146.     {

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

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

  1149.         return false;

  1150.     }

  1151. 

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

  1153.         return plugin->loadStateFromFile(filename);

  1154. 

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

  1156.     return false;

  1157. }

  1158. 

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

  1160. {

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

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

  1163. 

  1164.     if (gStandalone.engine == nullptr)

  1165.     {

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

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

  1168.         return false;

  1169.     }

  1170. 

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

  1172. 

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

  1174.         return plugin->saveStateToFile(filename);

  1175. 

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

  1177.     return false;

  1178. }

  1179. 

  1180. // -------------------------------------------------------------------------------------------------------------------

  1181. 

  1182. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1183. {

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

  1185. 

  1186.     static CarlaPluginInfo info;

  1187. 

  1188.     // reset

  1189.     info.type             = CB::PLUGIN_NONE;

  1190.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1191.     info.hints            = 0x0;

  1192.     info.optionsAvailable = 0x0;

  1193.     info.optionsEnabled   = 0x0;

  1194.     info.filename         = gNullCharPtr;

  1195.     info.name             = gNullCharPtr;

  1196.     info.iconName         = gNullCharPtr;

  1197.     info.uniqueId         = 0;

  1198. 

  1199.     // cleanup

  1200.     if (info.label != gNullCharPtr)

  1201.     {

  1202.         delete[] info.label;

  1203.         info.label = gNullCharPtr;

  1204.     }

  1205. 

  1206.     if (info.maker != gNullCharPtr)

  1207.     {

  1208.         delete[] info.maker;

  1209.         info.maker = gNullCharPtr;

  1210.     }

  1211. 

  1212.     if (info.copyright != gNullCharPtr)

  1213.     {

  1214.         delete[] info.copyright;

  1215.         info.copyright = gNullCharPtr;

  1216.     }

  1217. 

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

  1219. 

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

  1221.     {

  1222.         char strBufLabel[STR_MAX+1];

  1223.         char strBufMaker[STR_MAX+1];

  1224.         char strBufCopyright[STR_MAX+1];

  1225. 

  1226.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1227.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1228.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1229. 

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

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

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

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

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

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

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

  1237. 

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

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

  1240. 

  1241.         plugin->getLabel(strBufLabel);

  1242.         info.label = carla_strdup_safe(strBufLabel);

  1243. 

  1244.         plugin->getMaker(strBufMaker);

  1245.         info.maker = carla_strdup_safe(strBufMaker);

  1246. 

  1247.         plugin->getCopyright(strBufCopyright);

  1248.         info.copyright = carla_strdup_safe(strBufCopyright);

  1249. 

  1250.         checkStringPtr(info.filename);

  1251.         checkStringPtr(info.name);

  1252.         checkStringPtr(info.iconName);

  1253.         checkStringPtr(info.label);

  1254.         checkStringPtr(info.maker);

  1255.         checkStringPtr(info.copyright);

  1256. 

  1257.         return &info;

  1258.     }

  1259. 

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

  1261.     return &info;

  1262. }

  1263. 

  1264. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1265. {

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

  1267. 

  1268.     static CarlaPortCountInfo info;

  1269. 

  1270.     // reset

  1271.     info.ins   = 0;

  1272.     info.outs  = 0;

  1273. 

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

  1275. 

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

  1277.     {

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

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

  1280.         return &info;

  1281.     }

  1282. 

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

  1284.     return &info;

  1285. }

  1286. 

  1287. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1288. {

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

  1290. 

  1291.     static CarlaPortCountInfo info;

  1292. 

  1293.     // reset

  1294.     info.ins   = 0;

  1295.     info.outs  = 0;

  1296. 

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

  1298. 

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

  1300.     {

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

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

  1303.         return &info;

  1304.     }

  1305. 

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

  1307.     return &info;

  1308. }

  1309. 

  1310. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1311. {

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

  1313. 

  1314.     static CarlaPortCountInfo info;

  1315. 

  1316.     // reset

  1317.     info.ins   = 0;

  1318.     info.outs  = 0;

  1319. 

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

  1321. 

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

  1323.     {

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

  1325.         return &info;

  1326.     }

  1327. 

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

  1329.     return &info;

  1330. }

  1331. 

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

  1333. {

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

  1335. 

  1336.     static CarlaParameterInfo info;

  1337. 

  1338.     // reset

  1339.     info.scalePointCount = 0;

  1340. 

  1341.     // cleanup

  1342.     if (info.name != gNullCharPtr)

  1343.     {

  1344.         delete[] info.name;

  1345.         info.name = gNullCharPtr;

  1346.     }

  1347. 

  1348.     if (info.symbol != gNullCharPtr)

  1349.     {

  1350.         delete[] info.symbol;

  1351.         info.symbol = gNullCharPtr;

  1352.     }

  1353. 

  1354.     if (info.unit != gNullCharPtr)

  1355.     {

  1356.         delete[] info.unit;

  1357.         info.unit = gNullCharPtr;

  1358.     }

  1359. 

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

  1361. 

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

  1363.     {

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

  1365.         {

  1366.             char strBufName[STR_MAX+1];

  1367.             char strBufSymbol[STR_MAX+1];

  1368.             char strBufUnit[STR_MAX+1];

  1369. 

  1370.             carla_zeroChar(strBufName, STR_MAX+1);

  1371.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1372.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1373. 

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

  1375. 

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

  1377.             info.name = carla_strdup_safe(strBufName);

  1378. 

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

  1380.             info.symbol = carla_strdup_safe(strBufSymbol);

  1381. 

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

  1383.             info.unit = carla_strdup_safe(strBufUnit);

  1384. 

  1385.             checkStringPtr(info.name);

  1386.             checkStringPtr(info.symbol);

  1387.             checkStringPtr(info.unit);

  1388.         }

  1389.         else

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

  1391. 

  1392.         return &info;

  1393.     }

  1394. 

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

  1396.     return &info;

  1397. }

  1398. 

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

  1400. {

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

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

  1403. 

  1404.     static CarlaScalePointInfo info;

  1405. 

  1406.     // reset

  1407.     info.value = 0.0f;

  1408. 

  1409.     // cleanup

  1410.     if (info.label != gNullCharPtr)

  1411.     {

  1412.         delete[] info.label;

  1413.         info.label = gNullCharPtr;

  1414.     }

  1415. 

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

  1417. 

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

  1419.     {

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

  1421.         {

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

  1423.             {

  1424.                 char strBufLabel[STR_MAX+1];

  1425.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1426. 

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

  1428. 

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

  1430.                 info.label = carla_strdup_safe(strBufLabel);

  1431.                 checkStringPtr(info.label);

  1432.             }

  1433.             else

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

  1435.         }

  1436.         else

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

  1438. 

  1439.         return &info;

  1440.     }

  1441. 

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

  1443.     return &info;

  1444. }

  1445. 

  1446. // -------------------------------------------------------------------------------------------------------------------

  1447. 

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

  1449. {

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

  1451. 

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

  1453. 

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

  1455. 

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

  1457.     {

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

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

  1460. 

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

  1462.         return &fallbackParameterData;

  1463.     }

  1464. 

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

  1466.     return &fallbackParameterData;

  1467. }

  1468. 

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

  1470. {

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

  1472. 

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

  1474. 

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

  1476. 

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

  1478.     {

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

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

  1481. 

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

  1483.         return &fallbackParamRanges;

  1484.     }

  1485. 

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

  1487.     return &fallbackParamRanges;

  1488. }

  1489. 

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

  1491. {

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

  1493. 

  1494.     static MidiProgramData midiProgData;

  1495. 

  1496.     // reset

  1497.     midiProgData.bank    = 0;

  1498.     midiProgData.program = 0;

  1499.     midiProgData.name    = gNullCharPtr;

  1500. 

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

  1502. 

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

  1504.     {

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

  1506.         {

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

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

  1509.             checkStringPtr(midiProgData.name);

  1510.             return &midiProgData;

  1511.         }

  1512. 

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

  1514.         return &midiProgData;

  1515.     }

  1516. 

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

  1518.     return &midiProgData;

  1519. }

  1520. 

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

  1522. {

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

  1524. 

  1525.     static CustomData customData;

  1526. 

  1527.     // reset

  1528.     customData.type  = gNullCharPtr;

  1529.     customData.key   = gNullCharPtr;

  1530.     customData.value = gNullCharPtr;

  1531. 

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

  1533. 

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

  1535.     {

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

  1537.         {

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

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

  1540.             checkStringPtr(customData.type);

  1541.             checkStringPtr(customData.key);

  1542.             checkStringPtr(customData.value);

  1543.             return &customData;

  1544.         }

  1545. 

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

  1547.         return &customData;

  1548.     }

  1549. 

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

  1551.     return &customData;

  1552. }

  1553. 

  1554. const char* carla_get_chunk_data(uint pluginId)

  1555. {

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

  1557. 

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

  1559. 

  1560.     static CarlaString chunkData;

  1561. 

  1562.     // cleanup

  1563.     chunkData.clear();

  1564. 

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

  1566.     {

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

  1568.         {

  1569.             void* data = nullptr;

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

  1571. 

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

  1573.             {

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

  1575.                 return chunkData;

  1576.             }

  1577.             else

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

  1579.         }

  1580.         else

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

  1582. 

  1583.         return nullptr;

  1584.     }

  1585. 

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

  1587.     return nullptr;

  1588. }

  1589. 

  1590. // -------------------------------------------------------------------------------------------------------------------

  1591. 

  1592. uint32_t carla_get_parameter_count(uint pluginId)

  1593. {

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

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

  1596. 

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

  1598.         return plugin->getParameterCount();

  1599. 

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

  1601.     return 0;

  1602. }

  1603. 

  1604. uint32_t carla_get_program_count(uint pluginId)

  1605. {

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

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

  1608. 

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

  1610.         return plugin->getProgramCount();

  1611. 

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

  1613.     return 0;

  1614. }

  1615. 

  1616. uint32_t carla_get_midi_program_count(uint pluginId)

  1617. {

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

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

  1620. 

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

  1622.         return plugin->getMidiProgramCount();

  1623. 

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

  1625.     return 0;

  1626. }

  1627. 

  1628. uint32_t carla_get_custom_data_count(uint pluginId)

  1629. {

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

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

  1632. 

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

  1634.         return plugin->getCustomDataCount();

  1635. 

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

  1637.     return 0;

  1638. }

  1639. 

  1640. // -------------------------------------------------------------------------------------------------------------------

  1641. 

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

  1643. {

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

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

  1646. 

  1647.     static char textBuf[STR_MAX+1];

  1648. 

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

  1650.     {

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

  1652.         {

  1653.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1655.             return textBuf;

  1656.         }

  1657. 

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

  1659.         return nullptr;

  1660.     }

  1661. 

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

  1663.     return nullptr;

  1664. }

  1665. 

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

  1667. {

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

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

  1670. 

  1671.     static char programName[STR_MAX+1];

  1672. 

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

  1674.     {

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

  1676.         {

  1677.             carla_zeroChar(programName, STR_MAX+1);

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

  1679.             return programName;

  1680.         }

  1681. 

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

  1683.         return nullptr;

  1684.     }

  1685. 

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

  1687.     return nullptr;

  1688. }

  1689. 

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

  1691. {

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

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

  1694. 

  1695.     static char midiProgramName[STR_MAX+1];

  1696. 

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

  1698.     {

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

  1700.         {

  1701.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1703.             return midiProgramName;

  1704.         }

  1705. 

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

  1707.         return nullptr;

  1708.     }

  1709. 

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

  1711.     return nullptr;

  1712. }

  1713. 

  1714. const char* carla_get_real_plugin_name(uint pluginId)

  1715. {

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

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

  1718. 

  1719.     static char realPluginName[STR_MAX+1];

  1720. 

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

  1722.     {

  1723.         carla_zeroChar(realPluginName, STR_MAX+1);

  1724.         plugin->getRealName(realPluginName);

  1725.         return realPluginName;

  1726.     }

  1727. 

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

  1729.     return nullptr;

  1730. }

  1731. 

  1732. // -------------------------------------------------------------------------------------------------------------------

  1733. 

  1734. int32_t carla_get_current_program_index(uint pluginId)

  1735. {

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

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

  1738. 

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

  1740.         return plugin->getCurrentProgram();

  1741. 

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

  1743.     return -1;

  1744. }

  1745. 

  1746. int32_t carla_get_current_midi_program_index(uint pluginId)

  1747. {

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

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

  1750. 

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

  1752.         return plugin->getCurrentMidiProgram();

  1753. 

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

  1755.     return -1;

  1756. }

  1757. 

  1758. // -------------------------------------------------------------------------------------------------------------------

  1759. 

  1760. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1761. {

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

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

  1764. 

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

  1766.     {

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

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

  1769. 

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

  1771.         return 0.0f;

  1772.     }

  1773. 

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

  1775.     return 0.0f;

  1776. }

  1777. 

  1778. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1779. {

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

  1781. 

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

  1783.     {

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

  1785.             return plugin->getParameterValue(parameterId);

  1786. 

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

  1788.         return 0.0f;

  1789.     }

  1790. 

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

  1792.     return 0.0f;

  1793. }

  1794. 

  1795. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1796. {

  1797. #ifdef BUILD_BRIDGE

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

  1799. #else

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

  1801. #endif

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

  1803. 

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

  1805.         return plugin->getInternalParameterValue(parameterId);

  1806. 

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

  1808.     return 0.0f;

  1809. }

  1810. 

  1811. // -------------------------------------------------------------------------------------------------------------------

  1812. 

  1813. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1814. {

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

  1816. 

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

  1818. }

  1819. 

  1820. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1821. {

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

  1823. 

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

  1825. }

  1826. 

  1827. // -------------------------------------------------------------------------------------------------------------------

  1828. 

  1829. void carla_set_active(uint pluginId, bool onOff)

  1830. {

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

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

  1833. 

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

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

  1836. 

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

  1838. }

  1839. 

  1840. #ifndef BUILD_BRIDGE

  1841. void carla_set_drywet(uint pluginId, float value)

  1842. {

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

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

  1845. 

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

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

  1848. 

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

  1850. }

  1851. 

  1852. void carla_set_volume(uint pluginId, float value)

  1853. {

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

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

  1856. 

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

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

  1859. 

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

  1861. }

  1862. 

  1863. void carla_set_balance_left(uint pluginId, float value)

  1864. {

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

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

  1867. 

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

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

  1870. 

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

  1872. }

  1873. 

  1874. void carla_set_balance_right(uint pluginId, float value)

  1875. {

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

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

  1878. 

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

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

  1881. 

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

  1883. }

  1884. 

  1885. void carla_set_panning(uint pluginId, float value)

  1886. {

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

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

  1889. 

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

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

  1892. 

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

  1894. }

  1895. 

  1896. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1897. {

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

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

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

  1901. 

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

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

  1904. 

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

  1906. }

  1907. 

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

  1909. {

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

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

  1912. 

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

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

  1915. 

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

  1917. }

  1918. #endif

  1919. 

  1920. // -------------------------------------------------------------------------------------------------------------------

  1921. 

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

  1923. {

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

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

  1926. 

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

  1928.     {

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

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

  1931. 

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

  1933.         return;

  1934.     }

  1935. 

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

  1937. }

  1938. 

  1939. #ifndef BUILD_BRIDGE

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

  1941. {

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

  1943.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  1945. 

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

  1947.     {

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

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

  1950. 

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

  1952.         return;

  1953.     }

  1954. 

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

  1956. }

  1957. 

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

  1959. {

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

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

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

  1963. 

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

  1965.     {

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

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

  1968. 

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

  1970.         return;

  1971.     }

  1972. 

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

  1974. }

  1975. #endif

  1976. 

  1977. // -------------------------------------------------------------------------------------------------------------------

  1978. 

  1979. void carla_set_program(uint pluginId, uint32_t programId)

  1980. {

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

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

  1983. 

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

  1985.     {

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

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

  1988. 

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

  1990.         return;

  1991.     }

  1992. 

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

  1994. }

  1995. 

  1996. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  1997. {

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

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

  2000. 

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

  2002.     {

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

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

  2005. 

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

  2007.         return;

  2008.     }

  2009. 

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

  2011. }

  2012. 

  2013. // -------------------------------------------------------------------------------------------------------------------

  2014. 

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

  2016. {

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

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

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

  2020.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2022. 

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

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

  2025. 

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

  2027. }

  2028. 

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

  2030. {

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

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

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

  2034. 

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

  2036.     {

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

  2038.         {

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

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

  2041.         }

  2042. 

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

  2044.         return;

  2045.     }

  2046. 

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

  2048. }

  2049. 

  2050. // -------------------------------------------------------------------------------------------------------------------

  2051. 

  2052. void carla_prepare_for_save(uint pluginId)

  2053. {

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

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

  2056. 

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

  2058.         return plugin->prepareForSave();

  2059. 

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

  2061. }

  2062. 

  2063. void carla_reset_parameters(uint pluginId)

  2064. {

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

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

  2067. 

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

  2069.         return plugin->resetParameters();

  2070. 

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

  2072. }

  2073. 

  2074. void carla_randomize_parameters(uint pluginId)

  2075. {

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

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

  2078. 

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

  2080.         return plugin->randomizeParameters();

  2081. 

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

  2083. }

  2084. 

  2085. #ifndef BUILD_BRIDGE

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

  2087. {

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

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

  2090. 

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

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

  2093. 

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

  2095. }

  2096. #endif

  2097. 

  2098. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2099. {

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

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

  2102. 

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

  2104.         return plugin->showCustomUI(yesNo);

  2105. 

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

  2107. }

  2108. 

  2109. // -------------------------------------------------------------------------------------------------------------------

  2110. 

  2111. uint32_t carla_get_buffer_size()

  2112. {

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

  2114.     carla_debug("carla_get_buffer_size()");

  2115. 

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

  2117. }

  2118. 

  2119. double carla_get_sample_rate()

  2120. {

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

  2122.     carla_debug("carla_get_sample_rate()");

  2123. 

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

  2125. }

  2126. 

  2127. // -------------------------------------------------------------------------------------------------------------------

  2128. 

  2129. const char* carla_get_last_error()

  2130. {

  2131.     carla_debug("carla_get_last_error()");

  2132. 

  2133.     if (gStandalone.engine != nullptr)

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

  2135. 

  2136.     return gStandalone.lastError;

  2137. }

  2138. 

  2139. const char* carla_get_host_osc_url_tcp()

  2140. {

  2141.     carla_debug("carla_get_host_osc_url_tcp()");

  2142. 

  2143.     if (gStandalone.engine == nullptr)

  2144.     {

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

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

  2147.         return nullptr;

  2148.     }

  2149. 

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

  2151. }

  2152. 

  2153. const char* carla_get_host_osc_url_udp()

  2154. {

  2155.     carla_debug("carla_get_host_osc_url_udp()");

  2156. 

  2157.     if (gStandalone.engine == nullptr)

  2158.     {

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

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

  2161.         return nullptr;

  2162.     }

  2163. 

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

  2165. }

  2166. 

  2167. // -------------------------------------------------------------------------------------------------------------------

  2168. 

  2169. #include "CarlaPluginUI.cpp"

  2170. #include "CarlaDssiUtils.cpp"

  2171. #include "CarlaStateUtils.cpp"

  2172. #include "CarlaJuceEvents.cpp"

  2173. 

  2174. // -------------------------------------------------------------------------------------------------------------------