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

2259 lines
76KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

  3.  * Copyright (C) 2011-2013 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. #include "CarlaNative.h"

  24. 

  25. #include "CarlaEngine.hpp"

  26. #include "CarlaPlugin.hpp"

  27. 

  28. #include "CarlaBackendUtils.hpp"

  29. #include "CarlaOscUtils.hpp"

  30. 

  31. #include "juce_audio_formats.h"

  32. 

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

  34. # include "juce_gui_basics.h"

  35. #endif

  36. 

  37. namespace CB = CarlaBackend;

  38. using CB::EngineOptions;

  39. 

  40. // -------------------------------------------------------------------------------------------------------------------

  41. // Single, standalone engine

  42. 

  43. struct CarlaBackendStandalone {

  44.     CarlaEngine*       engine;

  45.     EngineCallbackFunc engineCallback;

  46.     void*              engineCallbackPtr;

  47.     EngineOptions      engineOptions;

  48. 

  49.     FileCallbackFunc fileCallback;

  50.     void*            fileCallbackPtr;

  51. 

  52.     CarlaString lastError;

  53. 

  54.     CarlaBackendStandalone()

  55.         : engine(nullptr),

  56.           engineCallback(nullptr),

  57.           engineCallbackPtr(nullptr),

  58.           fileCallback(nullptr),

  59.           fileCallbackPtr(nullptr)

  60.     {

  61. #ifdef BUILD_BRIDGE

  62.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  63.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  64.         engineOptions.forceStereo         = false;

  65.         engineOptions.preferPluginBridges = false;

  66.         engineOptions.preferUiBridges     = false;

  67. #else

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

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

  70. #endif

  71.     }

  72. 

  73.     ~CarlaBackendStandalone()

  74.     {

  75.         CARLA_SAFE_ASSERT(engine == nullptr);

  76.     }

  77. 

  78.     CARLA_PREVENT_HEAP_ALLOCATION

  79.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  80. };

  81. 

  82. static CarlaBackendStandalone gStandalone;

  83. 

  84. // -------------------------------------------------------------------------------------------------------------------

  85. // NSM support

  86. 

  87. #define NSM_API_VERSION_MAJOR 1

  88. #define NSM_API_VERSION_MINOR 2

  89. 

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

  91. #define NSM_CLIENT_FEATURES ":switch:"

  92. 

  93. class CarlaNSM

  94. {

  95. public:

  96.     CarlaNSM() noexcept

  97.         : fOscServer(nullptr),

  98.           fHasBroadcast(false),

  99.           fHasShowHideUI(false) {}

  100. 

  101.     ~CarlaNSM()

  102.     {

  103.         if (fOscServer != nullptr)

  104.         {

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

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

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

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

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

  110.             lo_server_free(fOscServer);

  111.             fOscServer = nullptr;

  112.         }

  113.     }

  114. 

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

  116.     {

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

  118. 

  119.         if (NSM_URL == nullptr)

  120.             return;

  121. 

  122.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  123. 

  124.         if (addr == nullptr)

  125.             return;

  126. 

  127.         const int proto = lo_address_get_protocol(addr);

  128. 

  129.         if (fOscServer == nullptr)

  130.         {

  131.             // create new OSC server

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

  133. 

  134.             // register message handlers and start OSC thread

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

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

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

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

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

  140.             // /nsm/client/session_is_loaded

  141.         }

  142. 

  143. #ifndef BUILD_ANSI_TEST

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

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

  146. #endif

  147. 

  148.         lo_address_free(addr);

  149.     }

  150. 

  151.     void idle() noexcept

  152.     {

  153.         if (fOscServer == nullptr)

  154.             return;

  155. 

  156.         for (;;)

  157.         {

  158.             try {

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

  160.                     break;

  161.             }

  162.             CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  163.         }

  164.     }

  165. 

  166. protected:

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

  168.     {

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

  170. 

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

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

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

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

  175. 

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

  177. 

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

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

  180. 

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

  182. 

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

  184. 

  185.         return 0;

  186. 

  187. #ifndef DEBUG

  188.         // unused

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

  190. #endif

  191.     }

  192. 

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

  194.     {

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

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

  197. 

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

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

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

  201. 

  202.         if (! carla_is_engine_running())

  203.         {

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

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

  206. 

  207.             carla_engine_init("JACK", clientId);

  208.         }

  209.         else

  210.         {

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

  212. 

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

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

  215.         }

  216. 

  217.         fClientId = clientId;

  218. 

  219.         fProjectPath  = projectPath;

  220.         fProjectPath += ".carxp";

  221. 

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

  223. 

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

  225. 

  226. #ifndef BUILD_ANSI_TEST

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

  228. #endif

  229. 

  230. #if 0

  231.         if (fHasBroadcast)

  232.         {

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

  234. 

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

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

  237. 

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

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

  240. 

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

  242. 

  243.             std::free(url);

  244. 

  245.             carla_stdout("Broadcast sent!");

  246.         }

  247.         else

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

  249. #endif

  250. 

  251.         return 0;

  252. 

  253. #ifndef DEBUG

  254.         // unused

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

  256. #endif

  257.     }

  258. 

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

  260.     {

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

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

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

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

  265. 

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

  267. 

  268. #ifndef BUILD_ANSI_TEST

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

  270. #endif

  271. 

  272.         return 0;

  273. 

  274. #ifndef DEBUG

  275.         // unused

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

  277. #endif

  278.     }

  279. 

  280. #if 0

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

  282.     {

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

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

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

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

  287. 

  288. #ifndef BUILD_ANSI_TEST

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

  290. #endif

  291. 

  292.         return 0;

  293.     }

  294. #endif

  295. 

  296. private:

  297.     lo_server fOscServer;

  298. 

  299.     CarlaString fClientId;

  300.     CarlaString fProjectPath;

  301. 

  302.     bool fHasBroadcast;

  303.     bool fHasShowHideUI;

  304. 

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

  306. 

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

  308.     {

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

  310.     }

  311. 

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

  313.     {

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

  315.     }

  316. 

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

  318.     {

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

  320.     }

  321. 

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

  323.     {

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

  325.     }

  326. 

  327. #if 0

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

  329.     {

  330.         return handlePtr->handleShowHideGui(true);

  331.     }

  332. 

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

  334.     {

  335.         return handlePtr->handleShowHideGui(false);

  336.     }

  337. #endif

  338. 

  339.     #undef handlePtr

  340. 

  341.     CARLA_PREVENT_HEAP_ALLOCATION

  342.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  343. };

  344. 

  345. static CarlaNSM gNSM;

  346. 

  347. // -------------------------------------------------------------------------------------------------------------------

  348. // Always return a valid string ptr

  349. 

  350. static const char* const gNullCharPtr = "";

  351. 

  352. static void checkStringPtr(const char*& charPtr)

  353. {

  354.     if (charPtr == nullptr)

  355.         charPtr = gNullCharPtr;

  356. }

  357. 

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

  359. // Constructors

  360. 

  361. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  362.     : type(CB::PLUGIN_NONE),

  363.       category(CB::PLUGIN_CATEGORY_NONE),

  364.       hints(0x0),

  365.       optionsAvailable(0x0),

  366.       optionsEnabled(0x0),

  367.       filename(gNullCharPtr),

  368.       name(gNullCharPtr),

  369.       label(gNullCharPtr),

  370.       maker(gNullCharPtr),

  371.       copyright(gNullCharPtr),

  372.       iconName(gNullCharPtr),

  373.       uniqueId(0) {}

  374. 

  375. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  376. {

  377.     if (label != gNullCharPtr)

  378.         delete[] label;

  379.     if (maker != gNullCharPtr)

  380.         delete[] maker;

  381.     if (copyright != gNullCharPtr)

  382.         delete[] copyright;

  383. }

  384. 

  385. _CarlaNativePluginInfo::_CarlaNativePluginInfo() noexcept

  386.     : category(CB::PLUGIN_CATEGORY_NONE),

  387.       hints(0x0),

  388.       audioIns(0),

  389.       audioOuts(0),

  390.       midiIns(0),

  391.       midiOuts(0),

  392.       parameterIns(0),

  393.       parameterOuts(0),

  394.       name(gNullCharPtr),

  395.       label(gNullCharPtr),

  396.       maker(gNullCharPtr),

  397.       copyright(gNullCharPtr) {}

  398. 

  399. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  400.     : name(gNullCharPtr),

  401.       symbol(gNullCharPtr),

  402.       unit(gNullCharPtr),

  403.       scalePointCount(0) {}

  404. 

  405. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  406. {

  407.     if (name != gNullCharPtr)

  408.         delete[] name;

  409.     if (symbol != gNullCharPtr)

  410.         delete[] symbol;

  411.     if (unit != gNullCharPtr)

  412.         delete[] unit;

  413. }

  414. 

  415. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  416.     : value(0.0f),

  417.       label(gNullCharPtr) {}

  418. 

  419. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  420. {

  421.     if (label != gNullCharPtr)

  422.         delete[] label;

  423. }

  424. 

  425. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  426.     : playing(false),

  427.       frame(0),

  428.       bar(0),

  429.       beat(0),

  430.       tick(0),

  431.       bpm(0.0) {}

  432. 

  433. // -------------------------------------------------------------------------------------------------------------------

  434. // API

  435. 

  436. const char* carla_get_complete_license_text()

  437. {

  438.     carla_debug("carla_get_complete_license_text()");

  439. 

  440.     static CarlaString retText;

  441. 

  442.     if (retText.isEmpty())

  443.     {

  444.         CarlaString text1, text2, text3, text4, text5;

  445. 

  446.         text1 += "<p>This current Carla build is using the following features and 3rd-party code:</p>";

  447.         text1 += "<ul>";

  448. 

  449.         // Plugin formats

  450.         text2 += "<li>LADSPA plugin support, http://www.ladspa.org/</li>";

  451.         text2 += "<li>DSSI plugin support, http://dssi.sourceforge.net/</li>";

  452.         text2 += "<li>LV2 plugin support, http://lv2plug.in/</li>";

  453. #ifdef VESTIGE_HEADER

  454.         text2 += "<li>VST plugin support, using VeSTige header by Javier Serrano Polo</li>";

  455. #else

  456.         text2 += "<li>VST plugin support, using official VST SDK 2.4 (trademark of Steinberg Media Technologies GmbH)</li>";

  457. #endif

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

  459.         text2 += "<li>VST3 plugin support</li>"; // FIXME

  460. #endif

  461. #ifdef CARLA_OS_MAC

  462.         text2 += "<li>AU plugin support</li>"; // FIXME

  463. #endif

  464. 

  465.         // Sample kit libraries

  466. #ifdef HAVE_FLUIDSYNTH

  467.         text2 += "<li>FluidSynth library for SF2 support, http://www.fluidsynth.org/</li>";

  468. #endif

  469. #ifdef HAVE_LINUXSAMPLER

  470.         text2 += "<li>LinuxSampler library for GIG and SFZ support*, http://www.linuxsampler.org/</li>";

  471. #endif

  472. 

  473.         // Internal plugins

  474.         text3 += "<li>NekoFilter plugin code, based on lv2fil by Nedko Arnaudov and Fons Adriaensen</li>";

  475. #ifdef WANT_ZYNADDSUBFX

  476.         text3 += "<li>ZynAddSubFX plugin code, http://zynaddsubfx.sf.net/</li>";

  477. # ifdef WANT_ZYNADDSUBFX_UI

  478.         text3 += "<li>ZynAddSubFX UI using NTK, http://non.tuxfamily.org/wiki/NTK</li>";

  479. # endif

  480. #endif

  481. 

  482.         // misc libs

  483.         text4 += "<li>liblo library for OSC support, http://liblo.sourceforge.net/</li>";

  484.         text4 += "<li>serd, sord, sratom and lilv libraries for LV2 discovery, http://drobilla.net/software/lilv/</li>";

  485.         text4 += "<li>RtAudio+RtMidi libraries for extra Audio and MIDI support, http://www.music.mcgill.ca/~gary/rtaudio/</li>";

  486. 

  487.         // end

  488.         text4 += "</ul>";

  489. 

  490. #ifdef HAVE_LINUXSAMPLER

  491.         // LinuxSampler GPL exception

  492.         text4 += "<p>(*) Using LinuxSampler code in commercial hardware or software products is not allowed without prior written authorization by the authors.</p>";

  493. #endif

  494. 

  495.         retText = text1 + text2 + text3 + text4;

  496.     }

  497. 

  498.     return retText;

  499. }

  500. 

  501. const char* carla_get_supported_file_extensions()

  502. {

  503.     carla_debug("carla_get_supported_file_extensions()");

  504. 

  505.     static CarlaString retText;

  506. 

  507.     if (retText.isEmpty())

  508.     {

  509.         // Base types

  510.         retText += "*.carxp;*.carxs";

  511. 

  512.         // Sample kits

  513. #ifdef HAVE_FLUIDSYNTH

  514.         retText += ";*.sf2";

  515. #endif

  516. #ifdef HAVE_LINUXSAMPLER

  517.         retText += ";*.gig;*.sfz";

  518. #endif

  519. 

  520.         // Audio files

  521.         {

  522.             using namespace juce;

  523. 

  524.             AudioFormatManager afm;

  525.             afm.registerBasicFormats();

  526. 

  527.             for (AudioFormat **it=afm.begin(), **end=afm.end(); it != end; ++it)

  528.             {

  529.                 const StringArray& exts((*it)->getFileExtensions());

  530. 

  531.                 for (String *eit=exts.begin(), *eend=exts.end(); eit != eend; ++eit)

  532.                     retText += String(";*" + (*eit)).toRawUTF8();

  533.             }

  534.         }

  535. 

  536.         // MIDI files

  537.         retText += ";*.mid;*.midi";

  538. 

  539.         // Plugin presets

  540. #ifdef WANT_ZYNADDSUBFX

  541.         retText += ";*.xmz;*.xiz";

  542. #endif

  543.     }

  544. 

  545.     return retText;

  546. }

  547. 

  548. // -------------------------------------------------------------------------------------------------------------------

  549. 

  550. uint carla_get_engine_driver_count()

  551. {

  552.     carla_debug("carla_get_engine_driver_count()");

  553. 

  554.     return CarlaEngine::getDriverCount();

  555. }

  556. 

  557. const char* carla_get_engine_driver_name(uint index)

  558. {

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

  560. 

  561.     return CarlaEngine::getDriverName(index);

  562. }

  563. 

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

  565. {

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

  567. 

  568.     return CarlaEngine::getDriverDeviceNames(index);

  569. }

  570. 

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

  572. {

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

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

  575. 

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

  577.     {

  578.         static EngineDriverDeviceInfo devInfo;

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

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

  581. 

  582.         devInfo.hints       = ret->hints;

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

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

  585.         return &devInfo;

  586.     }

  587. 

  588.     return nullptr;

  589. }

  590. 

  591. // -------------------------------------------------------------------------------------------------------------------

  592. 

  593. uint carla_get_internal_plugin_count()

  594. {

  595.     carla_debug("carla_get_internal_plugin_count()");

  596. 

  597.     return static_cast<uint>(CarlaPlugin::getNativePluginCount());

  598. }

  599. 

  600. const CarlaNativePluginInfo* carla_get_internal_plugin_info(uint index)

  601. {

  602.     carla_debug("carla_get_internal_plugin_info(%i)", index);

  603. 

  604.     static CarlaNativePluginInfo info;

  605. 

  606.     const NativePluginDescriptor* const nativePlugin(CarlaPlugin::getNativePluginDescriptor(index));

  607. 

  608.     // as internal plugin, this must never fail

  609.     CARLA_SAFE_ASSERT_RETURN(nativePlugin != nullptr, nullptr);

  610. 

  611.      info.category = static_cast<CB::PluginCategory>(nativePlugin->category);

  612.      info.hints    = 0x0;

  613. 

  614.      if (nativePlugin->hints & ::PLUGIN_IS_RTSAFE)

  615.          info.hints |= CB::PLUGIN_IS_RTSAFE;

  616.      if (nativePlugin->hints & ::PLUGIN_IS_SYNTH)

  617.          info.hints |= CB::PLUGIN_IS_SYNTH;

  618.      if (nativePlugin->hints & ::PLUGIN_HAS_UI)

  619.          info.hints |= CB::PLUGIN_HAS_CUSTOM_UI;

  620.      if (nativePlugin->hints & ::PLUGIN_NEEDS_FIXED_BUFFERS)

  621.          info.hints |= CB::PLUGIN_NEEDS_FIXED_BUFFERS;

  622.      if (nativePlugin->hints & ::PLUGIN_NEEDS_SINGLE_THREAD)

  623.          info.hints |= CB::PLUGIN_NEEDS_SINGLE_THREAD;

  624. 

  625.      info.audioIns  = nativePlugin->audioIns;

  626.      info.audioOuts = nativePlugin->audioOuts;

  627.      info.midiIns   = nativePlugin->midiIns;

  628.      info.midiOuts  = nativePlugin->midiOuts;

  629.      info.parameterIns  = nativePlugin->paramIns;

  630.      info.parameterOuts = nativePlugin->paramOuts;

  631. 

  632.      info.name      = nativePlugin->name;

  633.      info.label     = nativePlugin->label;

  634.      info.maker     = nativePlugin->maker;

  635.      info.copyright = nativePlugin->copyright;

  636. 

  637.      checkStringPtr(info.name);

  638.      checkStringPtr(info.label);

  639.      checkStringPtr(info.maker);

  640.      checkStringPtr(info.copyright);

  641. 

  642.     return &info;

  643. }

  644. 

  645. // -------------------------------------------------------------------------------------------------------------------

  646. 

  647. const CarlaEngine* carla_get_engine()

  648. {

  649.     carla_debug("carla_get_engine()");

  650. 

  651.     return gStandalone.engine;

  652. }

  653. 

  654. // -------------------------------------------------------------------------------------------------------------------

  655. 

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

  657. {

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

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

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

  661. 

  662.     if (gStandalone.engine != nullptr)

  663.     {

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

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

  666.         return false;

  667.     }

  668. 

  669. #ifdef CARLA_OS_WIN

  670.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  671. #endif

  672. 

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

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

  675.     {

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

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

  678.     }

  679. 

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

  681. 

  682.     if (gStandalone.engine == nullptr)

  683.     {

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

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

  686.         return false;

  687.     }

  688. 

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

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

  691. 

  692. #ifdef BUILD_BRIDGE

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

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

  695. #else

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

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

  698. #endif

  699. 

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

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

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

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

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

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

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

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

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

  709. 

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

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

  712. 

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

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

  715. 

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

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

  718. 

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

  720.     {

  721.         char strBuf[STR_MAX+1];

  722.         std::sprintf(strBuf, P_UINTPTR, gStandalone.engineOptions.frontendWinId);

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

  724.     }

  725.     else

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

  727. 

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

  729.     {

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

  731.         juce::initialiseJuce_GUI();

  732. #endif

  733.         gStandalone.lastError = "No error";

  734.         return true;

  735.     }

  736.     else

  737.     {

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

  739.         delete gStandalone.engine;

  740.         gStandalone.engine = nullptr;

  741.         return false;

  742.     }

  743. }

  744. 

  745. #ifdef BUILD_BRIDGE

  746. bool carla_engine_init_bridge(const char audioBaseName[6+1], const char controlBaseName[6+1], const char timeBaseName[6+1], const char* clientName)

  747. {

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

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

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

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

  752.     carla_debug("carla_engine_init_bridge(\"%s\", \"%s\", \"%s\", \"%s\")", audioBaseName, controlBaseName, timeBaseName, clientName);

  753. 

  754.     if (gStandalone.engine != nullptr)

  755.     {

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

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

  758.         return false;

  759.     }

  760. 

  761.     gStandalone.engine = CarlaEngine::newBridge(audioBaseName, controlBaseName, timeBaseName);

  762. 

  763.     if (gStandalone.engine == nullptr)

  764.     {

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

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

  767.         return false;

  768.     }

  769. 

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

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

  772. 

  773.     // forced options for bridge mode

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

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

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

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

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

  779. 

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

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

  782. 

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

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

  785. 

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

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

  788. 

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

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

  791. 

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

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

  794. 

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

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

  797. 

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

  799.     {

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

  801.         juce::initialiseJuce_GUI();

  802. #endif

  803.         gStandalone.lastError = "No error";

  804.         return true;

  805.     }

  806.     else

  807.     {

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

  809.         delete gStandalone.engine;

  810.         gStandalone.engine = nullptr;

  811.         return false;

  812.     }

  813. }

  814. #endif

  815. 

  816. bool carla_engine_close()

  817. {

  818.     carla_debug("carla_engine_close()");

  819. 

  820.     if (gStandalone.engine == nullptr)

  821.     {

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

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

  824.         return false;

  825.     }

  826. 

  827.     gStandalone.engine->setAboutToClose();

  828.     gStandalone.engine->removeAllPlugins();

  829. 

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

  831. 

  832.     if (! closed)

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

  834. 

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

  836.     juce::shutdownJuce_GUI();

  837. #endif

  838.     delete gStandalone.engine;

  839.     gStandalone.engine = nullptr;

  840. 

  841.     return closed;

  842. }

  843. 

  844. void carla_engine_idle()

  845. {

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

  847. 

  848.     gNSM.idle();

  849.     gStandalone.engine->idle();

  850. }

  851. 

  852. bool carla_is_engine_running()

  853. {

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

  855. }

  856. 

  857. void carla_set_engine_about_to_close()

  858. {

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

  860.     carla_debug("carla_set_engine_about_to_close()");

  861. 

  862.     gStandalone.engine->setAboutToClose();

  863. }

  864. 

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

  866. {

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

  868. 

  869.     gStandalone.engineCallback    = func;

  870.     gStandalone.engineCallbackPtr = ptr;

  871. 

  872.     if (gStandalone.engine != nullptr)

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

  874. 

  875. //#ifdef WANT_LOGS

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

  877. //#endif

  878. }

  879. 

  880. #ifndef BUILD_BRIDGE

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

  882. {

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

  884. 

  885.     switch (option)

  886.     {

  887.     case CB::ENGINE_OPTION_DEBUG:

  888.         break;

  889. 

  890.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  893.         break;

  894. 

  895.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  898.         break;

  899. 

  900.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  903.         break;

  904. 

  905.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  908.         break;

  909. 

  910.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  913.         break;

  914. 

  915.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  918.         break;

  919. 

  920.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  921.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  923.         break;

  924. 

  925.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  926.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  928.         break;

  929. 

  930.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  933.         break;

  934. 

  935.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  936.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  938.         break;

  939. 

  940.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  941.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  943.         break;

  944. 

  945.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  946.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  947. 

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

  949.             delete[] gStandalone.engineOptions.audioDevice;

  950. 

  951.         gStandalone.engineOptions.audioDevice = carla_strdup(valueStr);

  952.         break;

  953. 

  954.     case CB:: ENGINE_OPTION_NSM_INIT:

  955.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  957.         gNSM.announce(value, valueStr);

  958.         break;

  959. 

  960.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  962. 

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

  964.             delete[] gStandalone.engineOptions.binaryDir;

  965. 

  966.         gStandalone.engineOptions.binaryDir = carla_strdup(valueStr);

  967.         break;

  968. 

  969.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  971. 

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

  973.             delete[] gStandalone.engineOptions.resourceDir;

  974. 

  975.         gStandalone.engineOptions.resourceDir = carla_strdup(valueStr);

  976.         break;

  977. 

  978.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  981.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  983.         break;

  984.     }

  985. 

  986.     if (gStandalone.engine != nullptr)

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

  988. }

  989. #endif

  990. 

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

  992. {

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

  994. 

  995.     gStandalone.fileCallback    = func;

  996.     gStandalone.fileCallbackPtr = ptr;

  997. 

  998.     if (gStandalone.engine != nullptr)

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

  1000. }

  1001. 

  1002. // -------------------------------------------------------------------------------------------------------------------

  1003. 

  1004. bool carla_load_file(const char* filename)

  1005. {

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

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

  1008. 

  1009.     if (gStandalone.engine != nullptr)

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

  1011. 

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

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

  1014.     return false;

  1015. }

  1016. 

  1017. bool carla_load_project(const char* filename)

  1018. {

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

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

  1021. 

  1022.     if (gStandalone.engine != nullptr)

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

  1024. 

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

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

  1027.     return false;

  1028. }

  1029. 

  1030. bool carla_save_project(const char* filename)

  1031. {

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

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

  1034. 

  1035.     if (gStandalone.engine != nullptr)

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

  1037. 

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

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

  1040.     return false;

  1041. }

  1042. 

  1043. #ifndef BUILD_BRIDGE

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

  1045. 

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

  1047. {

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

  1049. 

  1050.     if (gStandalone.engine != nullptr)

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

  1052. 

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

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

  1055.     return false;

  1056. }

  1057. 

  1058. bool carla_patchbay_disconnect(uint connectionId)

  1059. {

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

  1061. 

  1062.     if (gStandalone.engine != nullptr)

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

  1064. 

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

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

  1067.     return false;

  1068. }

  1069. 

  1070. bool carla_patchbay_refresh()

  1071. {

  1072.     carla_debug("carla_patchbay_refresh()");

  1073. 

  1074.     if (gStandalone.engine != nullptr)

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

  1076. 

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

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

  1079.     return false;

  1080. }

  1081. #endif

  1082. 

  1083. // -------------------------------------------------------------------------------------------------------------------

  1084. 

  1085. void carla_transport_play()

  1086. {

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

  1088.     carla_debug("carla_transport_play()");

  1089. 

  1090.     gStandalone.engine->transportPlay();

  1091. }

  1092. 

  1093. void carla_transport_pause()

  1094. {

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

  1096.     carla_debug("carla_transport_pause()");

  1097. 

  1098.     gStandalone.engine->transportPause();

  1099. }

  1100. 

  1101. void carla_transport_relocate(uint64_t frame)

  1102. {

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

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

  1105. 

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

  1107. }

  1108. 

  1109. uint64_t carla_get_current_transport_frame()

  1110. {

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

  1112. 

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

  1114.     return timeInfo.frame;

  1115. }

  1116. 

  1117. const CarlaTransportInfo* carla_get_transport_info()

  1118. {

  1119.     static CarlaTransportInfo retInfo;

  1120. 

  1121.     // reset

  1122.     retInfo.playing = false;

  1123.     retInfo.frame   = 0;

  1124.     retInfo.bar     = 0;

  1125.     retInfo.beat    = 0;

  1126.     retInfo.tick    = 0;

  1127.     retInfo.bpm     = 0.0;

  1128. 

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

  1130. 

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

  1132. 

  1133.     retInfo.playing = timeInfo.playing;

  1134.     retInfo.frame   = timeInfo.frame;

  1135. 

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

  1137.     {

  1138.         retInfo.bar  = timeInfo.bbt.bar;

  1139.         retInfo.beat = timeInfo.bbt.beat;

  1140.         retInfo.tick = timeInfo.bbt.tick;

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

  1142.     }

  1143. 

  1144.     return &retInfo;

  1145. }

  1146. 

  1147. // -------------------------------------------------------------------------------------------------------------------

  1148. 

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

  1150. {

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

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

  1153. 

  1154.     if (gStandalone.engine != nullptr)

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

  1156. 

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

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

  1159.     return false;

  1160. }

  1161. 

  1162. bool carla_remove_plugin(uint pluginId)

  1163. {

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

  1165. 

  1166.     if (gStandalone.engine != nullptr)

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

  1168. 

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

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

  1171.     return false;

  1172. }

  1173. 

  1174. bool carla_remove_all_plugins()

  1175. {

  1176.     carla_debug("carla_remove_all_plugins()");

  1177. 

  1178.     if (gStandalone.engine != nullptr)

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

  1180. 

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

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

  1183.     return false;

  1184. }

  1185. 

  1186. #ifndef BUILD_BRIDGE

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

  1188. {

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

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

  1191. 

  1192.     if (gStandalone.engine != nullptr)

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

  1194. 

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

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

  1197.     return nullptr;

  1198. }

  1199. 

  1200. bool carla_clone_plugin(uint pluginId)

  1201. {

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

  1203. 

  1204.     if (gStandalone.engine != nullptr)

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

  1206. 

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

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

  1209.     return false;

  1210. }

  1211. 

  1212. bool carla_replace_plugin(uint pluginId)

  1213. {

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

  1215. 

  1216.     if (gStandalone.engine != nullptr)

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

  1218. 

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

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

  1221.     return false;

  1222. }

  1223. 

  1224. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1225. {

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

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

  1228. 

  1229.     if (gStandalone.engine != nullptr)

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

  1231. 

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

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

  1234.     return false;

  1235. }

  1236. #endif

  1237. 

  1238. // -------------------------------------------------------------------------------------------------------------------

  1239. 

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

  1241. {

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

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

  1244. 

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

  1246.     {

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

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

  1249.         return false;

  1250.     }

  1251. 

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

  1253.         return plugin->loadStateFromFile(filename);

  1254. 

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

  1256.     return false;

  1257. }

  1258. 

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

  1260. {

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

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

  1263. 

  1264.     if (gStandalone.engine == nullptr)

  1265.     {

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

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

  1268.         return false;

  1269.     }

  1270. 

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

  1272. 

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

  1274.         return plugin->saveStateToFile(filename);

  1275. 

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

  1277.     return false;

  1278. }

  1279. 

  1280. // -------------------------------------------------------------------------------------------------------------------

  1281. 

  1282. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1283. {

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

  1285. 

  1286.     static CarlaPluginInfo info;

  1287. 

  1288.     // reset

  1289.     info.type             = CB::PLUGIN_NONE;

  1290.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1291.     info.hints            = 0x0;

  1292.     info.optionsAvailable = 0x0;

  1293.     info.optionsEnabled   = 0x0;

  1294.     info.filename         = gNullCharPtr;

  1295.     info.name             = gNullCharPtr;

  1296.     info.iconName         = gNullCharPtr;

  1297.     info.uniqueId         = 0;

  1298. 

  1299.     // cleanup

  1300.     if (info.label != gNullCharPtr)

  1301.     {

  1302.         delete[] info.label;

  1303.         info.label = gNullCharPtr;

  1304.     }

  1305. 

  1306.     if (info.maker != gNullCharPtr)

  1307.     {

  1308.         delete[] info.maker;

  1309.         info.maker = gNullCharPtr;

  1310.     }

  1311. 

  1312.     if (info.copyright != gNullCharPtr)

  1313.     {

  1314.         delete[] info.copyright;

  1315.         info.copyright = gNullCharPtr;

  1316.     }

  1317. 

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

  1319. 

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

  1321.     {

  1322.         char strBufLabel[STR_MAX+1];

  1323.         char strBufMaker[STR_MAX+1];

  1324.         char strBufCopyright[STR_MAX+1];

  1325. 

  1326.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1327.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1328.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1329. 

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

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

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

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

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

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

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

  1337. 

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

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

  1340. 

  1341.         plugin->getLabel(strBufLabel);

  1342.         info.label = carla_strdup(strBufLabel);

  1343. 

  1344.         plugin->getMaker(strBufMaker);

  1345.         info.maker = carla_strdup(strBufMaker);

  1346. 

  1347.         plugin->getCopyright(strBufCopyright);

  1348.         info.copyright = carla_strdup(strBufCopyright);

  1349. 

  1350.         checkStringPtr(info.filename);

  1351.         checkStringPtr(info.name);

  1352.         checkStringPtr(info.iconName);

  1353. 

  1354.         return &info;

  1355.     }

  1356. 

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

  1358.     return &info;

  1359. }

  1360. 

  1361. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1362. {

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

  1364. 

  1365.     static CarlaPortCountInfo info;

  1366. 

  1367.     // reset

  1368.     info.ins   = 0;

  1369.     info.outs  = 0;

  1370. 

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

  1372. 

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

  1374.     {

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

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

  1377.         return &info;

  1378.     }

  1379. 

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

  1381.     return &info;

  1382. }

  1383. 

  1384. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1385. {

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

  1387. 

  1388.     static CarlaPortCountInfo info;

  1389. 

  1390.     // reset

  1391.     info.ins   = 0;

  1392.     info.outs  = 0;

  1393. 

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

  1395. 

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

  1397.     {

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

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

  1400.         return &info;

  1401.     }

  1402. 

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

  1404.     return &info;

  1405. }

  1406. 

  1407. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1408. {

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

  1410. 

  1411.     static CarlaPortCountInfo info;

  1412. 

  1413.     // reset

  1414.     info.ins   = 0;

  1415.     info.outs  = 0;

  1416. 

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

  1418. 

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

  1420.     {

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

  1422.         return &info;

  1423.     }

  1424. 

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

  1426.     return &info;

  1427. }

  1428. 

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

  1430. {

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

  1432. 

  1433.     static CarlaParameterInfo info;

  1434. 

  1435.     // reset

  1436.     info.scalePointCount = 0;

  1437. 

  1438.     // cleanup

  1439.     if (info.name != gNullCharPtr)

  1440.     {

  1441.         delete[] info.name;

  1442.         info.name = gNullCharPtr;

  1443.     }

  1444. 

  1445.     if (info.symbol != gNullCharPtr)

  1446.     {

  1447.         delete[] info.symbol;

  1448.         info.symbol = gNullCharPtr;

  1449.     }

  1450. 

  1451.     if (info.unit != gNullCharPtr)

  1452.     {

  1453.         delete[] info.unit;

  1454.         info.unit = gNullCharPtr;

  1455.     }

  1456. 

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

  1458. 

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

  1460.     {

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

  1462.         {

  1463.             char strBufName[STR_MAX+1];

  1464.             char strBufSymbol[STR_MAX+1];

  1465.             char strBufUnit[STR_MAX+1];

  1466. 

  1467.             carla_zeroChar(strBufName, STR_MAX+1);

  1468.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1469.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1470. 

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

  1472. 

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

  1474.             info.name = carla_strdup(strBufName);

  1475. 

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

  1477.             info.symbol = carla_strdup(strBufSymbol);

  1478. 

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

  1480.             info.unit = carla_strdup(strBufUnit);

  1481.         }

  1482.         else

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

  1484. 

  1485.         return &info;

  1486.     }

  1487. 

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

  1489.     return &info;

  1490. }

  1491. 

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

  1493. {

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

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

  1496. 

  1497.     static CarlaScalePointInfo info;

  1498. 

  1499.     // reset

  1500.     info.value = 0.0f;

  1501. 

  1502.     // cleanup

  1503.     if (info.label != gNullCharPtr)

  1504.     {

  1505.         delete[] info.label;

  1506.         info.label = gNullCharPtr;

  1507.     }

  1508. 

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

  1510. 

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

  1512.     {

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

  1514.         {

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

  1516.             {

  1517.                 char strBufLabel[STR_MAX+1];

  1518.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1519. 

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

  1521. 

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

  1523.                 info.label = carla_strdup(strBufLabel);

  1524.             }

  1525.             else

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

  1527.         }

  1528.         else

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

  1530. 

  1531.         return &info;

  1532.     }

  1533. 

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

  1535.     return &info;

  1536. }

  1537. 

  1538. // -------------------------------------------------------------------------------------------------------------------

  1539. 

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

  1541. {

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

  1543. 

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

  1545. 

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

  1547. 

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

  1549.     {

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

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

  1552. 

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

  1554.         return &fallbackParameterData;

  1555.     }

  1556. 

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

  1558.     return &fallbackParameterData;

  1559. }

  1560. 

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

  1562. {

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

  1564. 

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

  1566. 

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

  1568. 

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

  1570.     {

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

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

  1573. 

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

  1575.         return &fallbackParamRanges;

  1576.     }

  1577. 

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

  1579.     return &fallbackParamRanges;

  1580. }

  1581. 

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

  1583. {

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

  1585. 

  1586.     static MidiProgramData midiProgData;

  1587. 

  1588.     // reset

  1589.     midiProgData.bank    = 0;

  1590.     midiProgData.program = 0;

  1591.     midiProgData.name    = gNullCharPtr;

  1592. 

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

  1594. 

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

  1596.     {

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

  1598.         {

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

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

  1601.             checkStringPtr(midiProgData.name);

  1602.             return &midiProgData;

  1603.         }

  1604. 

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

  1606.         return &midiProgData;

  1607.     }

  1608. 

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

  1610.     return &midiProgData;

  1611. }

  1612. 

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

  1614. {

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

  1616. 

  1617.     static CustomData customData;

  1618. 

  1619.     // reset

  1620.     customData.type  = gNullCharPtr;

  1621.     customData.key   = gNullCharPtr;

  1622.     customData.value = gNullCharPtr;

  1623. 

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

  1625. 

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

  1627.     {

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

  1629.         {

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

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

  1632.             checkStringPtr(customData.type);

  1633.             checkStringPtr(customData.key);

  1634.             checkStringPtr(customData.value);

  1635.             return &customData;

  1636.         }

  1637. 

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

  1639.         return &customData;

  1640.     }

  1641. 

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

  1643.     return &customData;

  1644. }

  1645. 

  1646. const char* carla_get_chunk_data(uint pluginId)

  1647. {

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

  1649. 

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

  1651. 

  1652.     static CarlaString chunkData;

  1653. 

  1654.     // cleanup

  1655.     chunkData.clear();

  1656. 

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

  1658.     {

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

  1660.         {

  1661.             void* data = nullptr;

  1662.             const int32_t dataSize(plugin->getChunkData(&data));

  1663. 

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

  1665.             {

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

  1667. 

  1668.                 return chunkData;

  1669.             }

  1670.             else

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

  1672.         }

  1673.         else

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

  1675. 

  1676.         return nullptr;

  1677.     }

  1678. 

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

  1680.     return nullptr;

  1681. }

  1682. 

  1683. // -------------------------------------------------------------------------------------------------------------------

  1684. 

  1685. uint32_t carla_get_parameter_count(uint pluginId)

  1686. {

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

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

  1689. 

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

  1691.         return plugin->getParameterCount();

  1692. 

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

  1694.     return 0;

  1695. }

  1696. 

  1697. uint32_t carla_get_program_count(uint pluginId)

  1698. {

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

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

  1701. 

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

  1703.         return plugin->getProgramCount();

  1704. 

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

  1706.     return 0;

  1707. }

  1708. 

  1709. uint32_t carla_get_midi_program_count(uint pluginId)

  1710. {

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

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

  1713. 

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

  1715.         return plugin->getMidiProgramCount();

  1716. 

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

  1718.     return 0;

  1719. }

  1720. 

  1721. uint32_t carla_get_custom_data_count(uint pluginId)

  1722. {

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

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

  1725. 

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

  1727.         return plugin->getCustomDataCount();

  1728. 

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

  1730.     return 0;

  1731. }

  1732. 

  1733. // -------------------------------------------------------------------------------------------------------------------

  1734. 

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

  1736. {

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

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

  1739. 

  1740.     static char textBuf[STR_MAX+1];

  1741. 

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

  1743.     {

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

  1745.         {

  1746.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1748.             return textBuf;

  1749.         }

  1750. 

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

  1752.         return nullptr;

  1753.     }

  1754. 

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

  1756.     return nullptr;

  1757. }

  1758. 

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

  1760. {

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

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

  1763. 

  1764.     static char programName[STR_MAX+1];

  1765. 

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

  1767.     {

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

  1769.         {

  1770.             carla_zeroChar(programName, STR_MAX+1);

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

  1772.             return programName;

  1773.         }

  1774. 

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

  1776.         return nullptr;

  1777.     }

  1778. 

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

  1780.     return nullptr;

  1781. }

  1782. 

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

  1784. {

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

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

  1787. 

  1788.     static char midiProgramName[STR_MAX+1];

  1789. 

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

  1791.     {

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

  1793.         {

  1794.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1796.             return midiProgramName;

  1797.         }

  1798. 

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

  1800.         return nullptr;

  1801.     }

  1802. 

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

  1804.     return nullptr;

  1805. }

  1806. 

  1807. const char* carla_get_real_plugin_name(uint pluginId)

  1808. {

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

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

  1811. 

  1812.     static char realPluginName[STR_MAX+1];

  1813. 

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

  1815.     {

  1816.         carla_zeroChar(realPluginName, STR_MAX+1);

  1817.         plugin->getRealName(realPluginName);

  1818.         return realPluginName;

  1819.     }

  1820. 

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

  1822.     return nullptr;

  1823. }

  1824. 

  1825. // -------------------------------------------------------------------------------------------------------------------

  1826. 

  1827. int32_t carla_get_current_program_index(uint pluginId)

  1828. {

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

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

  1831. 

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

  1833.         return plugin->getCurrentProgram();

  1834. 

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

  1836.     return -1;

  1837. }

  1838. 

  1839. int32_t carla_get_current_midi_program_index(uint pluginId)

  1840. {

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

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

  1843. 

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

  1845.         return plugin->getCurrentMidiProgram();

  1846. 

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

  1848.     return -1;

  1849. }

  1850. 

  1851. // -------------------------------------------------------------------------------------------------------------------

  1852. 

  1853. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1854. {

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

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

  1857. 

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

  1859.     {

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

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

  1862. 

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

  1864.         return 0.0f;

  1865.     }

  1866. 

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

  1868.     return 0.0f;

  1869. }

  1870. 

  1871. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1872. {

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

  1874. 

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

  1876.     {

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

  1878.             return plugin->getParameterValue(parameterId);

  1879. 

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

  1881.         return 0.0f;

  1882.     }

  1883. 

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

  1885.     return 0.0f;

  1886. }

  1887. 

  1888. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  1889. {

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

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

  1892. 

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

  1894.         return plugin->getInternalParameterValue(parameterId);

  1895. 

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

  1897.     return 0.0f;

  1898. }

  1899. 

  1900. // -------------------------------------------------------------------------------------------------------------------

  1901. 

  1902. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  1903. {

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

  1905. 

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

  1907. }

  1908. 

  1909. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  1910. {

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

  1912. 

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

  1914. }

  1915. 

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

  1917. 

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

  1919. {

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

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

  1922. 

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

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

  1925. 

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

  1927. }

  1928. 

  1929. void carla_set_active(uint pluginId, bool onOff)

  1930. {

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

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

  1933. 

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

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

  1936. 

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

  1938. }

  1939. 

  1940. #ifndef BUILD_BRIDGE

  1941. void carla_set_drywet(uint pluginId, float value)

  1942. {

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

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

  1945. 

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

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

  1948. 

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

  1950. }

  1951. 

  1952. void carla_set_volume(uint pluginId, float value)

  1953. {

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

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

  1956. 

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

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

  1959. 

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

  1961. }

  1962. 

  1963. void carla_set_balance_left(uint pluginId, float value)

  1964. {

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

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

  1967. 

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

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

  1970. 

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

  1972. }

  1973. 

  1974. void carla_set_balance_right(uint pluginId, float value)

  1975. {

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

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

  1978. 

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

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

  1981. 

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

  1983. }

  1984. 

  1985. void carla_set_panning(uint pluginId, float value)

  1986. {

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

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

  1989. 

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

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

  1992. 

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

  1994. }

  1995. #endif

  1996. 

  1997. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  1998. {

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

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

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

  2002. 

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

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

  2005. 

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

  2007. }

  2008. 

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

  2010. 

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

  2012. {

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

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

  2015. 

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

  2017.     {

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

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

  2020. 

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

  2022.         return;

  2023.     }

  2024. 

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

  2026. }

  2027. 

  2028. #ifndef BUILD_BRIDGE

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

  2030. {

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

  2032.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  2034. 

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

  2036.     {

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

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

  2039. 

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

  2041.         return;

  2042.     }

  2043. 

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

  2045. }

  2046. 

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

  2048. {

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

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

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

  2052. 

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

  2054.     {

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

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

  2057. 

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

  2059.         return;

  2060.     }

  2061. 

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

  2063. }

  2064. #endif

  2065. 

  2066. // -------------------------------------------------------------------------------------------------------------------

  2067. 

  2068. void carla_set_program(uint pluginId, uint32_t programId)

  2069. {

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

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

  2072. 

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

  2074.     {

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

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

  2077. 

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

  2079.         return;

  2080.     }

  2081. 

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

  2083. }

  2084. 

  2085. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2086. {

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

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

  2089. 

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

  2091.     {

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

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

  2094. 

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

  2096.         return;

  2097.     }

  2098. 

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

  2100. }

  2101. 

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

  2103. 

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

  2105. {

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

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

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

  2109.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2111. 

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

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

  2114. 

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

  2116. }

  2117. 

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

  2119. {

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

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

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

  2123. 

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

  2125.     {

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

  2127.             return plugin->setChunkData(chunkData);

  2128. 

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

  2130.         return;

  2131.     }

  2132. 

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

  2134. }

  2135. 

  2136. // -------------------------------------------------------------------------------------------------------------------

  2137. 

  2138. void carla_prepare_for_save(uint pluginId)

  2139. {

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

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

  2142. 

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

  2144.         return plugin->prepareForSave();

  2145. 

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

  2147. }

  2148. 

  2149. void carla_reset_parameters(uint pluginId)

  2150. {

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

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

  2153. 

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

  2155.         return plugin->resetParameters();

  2156. 

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

  2158. }

  2159. 

  2160. void carla_randomize_parameters(uint pluginId)

  2161. {

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

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

  2164. 

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

  2166.         return plugin->randomizeParameters();

  2167. 

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

  2169. }

  2170. 

  2171. #ifndef BUILD_BRIDGE

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

  2173. {

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

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

  2176. 

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

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

  2179. 

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

  2181. }

  2182. #endif

  2183. 

  2184. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2185. {

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

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

  2188. 

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

  2190.         return plugin->showCustomUI(yesNo);

  2191. 

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

  2193. }

  2194. 

  2195. // -------------------------------------------------------------------------------------------------------------------

  2196. 

  2197. uint32_t carla_get_buffer_size()

  2198. {

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

  2200.     carla_debug("carla_get_buffer_size()");

  2201. 

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

  2203. }

  2204. 

  2205. double carla_get_sample_rate()

  2206. {

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

  2208.     carla_debug("carla_get_sample_rate()");

  2209. 

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

  2211. }

  2212. 

  2213. // -------------------------------------------------------------------------------------------------------------------

  2214. 

  2215. const char* carla_get_last_error()

  2216. {

  2217.     carla_debug("carla_get_last_error()");

  2218. 

  2219.     if (gStandalone.engine != nullptr)

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

  2221. 

  2222.     return gStandalone.lastError;

  2223. }

  2224. 

  2225. const char* carla_get_host_osc_url_tcp()

  2226. {

  2227.     carla_debug("carla_get_host_osc_url_tcp()");

  2228. 

  2229.     if (gStandalone.engine == nullptr)

  2230.     {

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

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

  2233.         return nullptr;

  2234.     }

  2235. 

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

  2237. }

  2238. 

  2239. const char* carla_get_host_osc_url_udp()

  2240. {

  2241.     carla_debug("carla_get_host_osc_url_udp()");

  2242. 

  2243.     if (gStandalone.engine == nullptr)

  2244.     {

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

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

  2247.         return nullptr;

  2248.     }

  2249. 

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

  2251. }

  2252. 

  2253. // -------------------------------------------------------------------------------------------------------------------

  2254. 

  2255. #include "CarlaDssiUtils.cpp"

  2256. #include "CarlaStateUtils.cpp"

  2257. 

  2258. // -------------------------------------------------------------------------------------------------------------------