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

2432 lines
80KB
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. #include "CarlaThread.hpp"

  31. 

  32. #include <QtCore/QByteArray>

  33. 

  34. #ifdef BUILD_BRIDGE

  35. # undef HAVE_JUCE

  36. #endif

  37. 

  38. #ifdef HAVE_JUCE

  39. # include "juce_gui_basics.h"

  40. using juce::initialiseJuce_GUI;

  41. using juce::shutdownJuce_GUI;

  42. using juce::MessageManager;

  43. #endif

  44. 

  45. namespace CB = CarlaBackend;

  46. using CB::EngineOptions;

  47. 

  48. // -------------------------------------------------------------------------------------------------------------------

  49. // Juce Message Thread

  50. 

  51. #if defined(HAVE_JUCE) && defined(CARLA_OS_LINUX)

  52. 

  53. class JuceMessageThread : public juce::Thread

  54. {

  55. public:

  56.     JuceMessageThread()

  57.       : juce::Thread("JuceMessageThread"),

  58.         fInitialised(false)

  59.     {

  60.     }

  61. 

  62.     ~JuceMessageThread() override

  63.     {

  64.         stop();

  65.     }

  66. 

  67.     void start()

  68.     {

  69.         CARLA_SAFE_ASSERT_RETURN(! fInitialised,);

  70. 

  71.         fInitialised = false;

  72. 

  73.         startThread();

  74. 

  75.         while (! fInitialised)

  76.             Thread::sleep(1);

  77.     }

  78. 

  79.     void stop()

  80.     {

  81.         if (! fInitialised)

  82.             return;

  83. 

  84.         stopThread(-1);

  85.     }

  86. 

  87. protected:

  88.     void run() override

  89.     {

  90.         fInitialised = true;

  91. 

  92.         if (MessageManager* const msgMgr = MessageManager::getInstance())

  93.         {

  94.             msgMgr->setCurrentThreadAsMessageThread();

  95. 

  96.             for (; (! threadShouldExit()) && msgMgr->runDispatchLoopUntil(250);) {}

  97.         }

  98. 

  99.         fInitialised = false;

  100.     }

  101. 

  102. private:

  103.     volatile bool fInitialised;

  104. 

  105.     CARLA_DECLARE_NON_COPY_CLASS(JuceMessageThread)

  106. };

  107. 

  108. #endif // defined(HAVE_JUCE) && defined(CARLA_OS_LINUX)

  109. 

  110. // -------------------------------------------------------------------------------------------------------------------

  111. // Single, standalone engine

  112. 

  113. struct CarlaBackendStandalone {

  114.     CarlaEngine*       engine;

  115.     EngineCallbackFunc engineCallback;

  116.     void*              engineCallbackPtr;

  117.     EngineOptions      engineOptions;

  118. 

  119.     FileCallbackFunc fileCallback;

  120.     void*            fileCallbackPtr;

  121. 

  122.     CarlaString lastError;

  123. 

  124. #if defined(HAVE_JUCE) && defined(CARLA_OS_LINUX)

  125.     JuceMessageThread juceMsgThread;

  126. #endif

  127. 

  128.     CarlaBackendStandalone()

  129.         : engine(nullptr),

  130.           engineCallback(nullptr),

  131.           engineCallbackPtr(nullptr),

  132.           fileCallback(nullptr),

  133.           fileCallbackPtr(nullptr)

  134.     {

  135. #ifdef BUILD_BRIDGE

  136.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  137.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  138.         engineOptions.forceStereo         = false;

  139.         engineOptions.preferPluginBridges = false;

  140.         engineOptions.preferUiBridges     = false;

  141. #else

  142.         if (std::getenv("LADISH_APP_NAME") != nullptr || std::getenv("NSM_URL") != nullptr)

  143.             return;

  144. 

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

  146. #endif

  147.     }

  148. 

  149.     ~CarlaBackendStandalone()

  150.     {

  151.         CARLA_SAFE_ASSERT(engine == nullptr);

  152. #ifdef HAVE_JUCE

  153.         CARLA_SAFE_ASSERT(MessageManager::getInstanceWithoutCreating() == nullptr);

  154. #endif

  155.     }

  156. 

  157. #ifdef HAVE_JUCE

  158.     void init()

  159.     {

  160.         JUCE_AUTORELEASEPOOL

  161.         {

  162.             initialiseJuce_GUI();

  163. # ifdef CARLA_OS_LINUX

  164.             juceMsgThread.start();

  165. # else

  166.             if (MessageManager* const msgMgr = MessageManager::getInstance())

  167.                 msgMgr->setCurrentThreadAsMessageThread();

  168. # endif

  169.         }

  170.     }

  171. 

  172.     void close()

  173.     {

  174.         JUCE_AUTORELEASEPOOL

  175.         {

  176. # ifdef CARLA_OS_LINUX

  177.             juceMsgThread.stop();

  178. # else

  179.             MessageManager::deleteInstance();

  180. # endif

  181.             shutdownJuce_GUI();

  182.         }

  183.     }

  184. 

  185. # ifndef CARLA_OS_LINUX

  186.     void idle()

  187.     {

  188.         JUCE_AUTORELEASEPOOL

  189.         {

  190.             if (MessageManager* const msgMgr = MessageManager::getInstanceWithoutCreating())

  191.                 msgMgr->runDispatchLoopUntil(5);

  192.         }

  193.     }

  194. # endif

  195. #endif

  196. 

  197.     CARLA_PREVENT_HEAP_ALLOCATION

  198.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  199. };

  200. 

  201. static CarlaBackendStandalone gStandalone;

  202. 

  203. // -------------------------------------------------------------------------------------------------------------------

  204. // NSM support

  205. 

  206. #define NSM_API_VERSION_MAJOR 1

  207. #define NSM_API_VERSION_MINOR 2

  208. 

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

  210. #define NSM_CLIENT_FEATURES ":switch:"

  211. 

  212. class CarlaNSM

  213. {

  214. public:

  215.     CarlaNSM() noexcept

  216.         : fOscServer(nullptr),

  217.           fHasBroadcast(false),

  218.           fHasShowHideUI(false) {}

  219. 

  220.     ~CarlaNSM()

  221.     {

  222.         if (fOscServer != nullptr)

  223.         {

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

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

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

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

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

  229.             lo_server_free(fOscServer);

  230.             fOscServer = nullptr;

  231.         }

  232.     }

  233. 

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

  235.     {

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

  237. 

  238.         if (NSM_URL == nullptr)

  239.             return;

  240. 

  241.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  242. 

  243.         if (addr == nullptr)

  244.             return;

  245. 

  246.         const int proto = lo_address_get_protocol(addr);

  247. 

  248.         if (fOscServer == nullptr)

  249.         {

  250.             // create new OSC server

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

  252. 

  253.             // register message handlers and start OSC thread

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

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

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

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

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

  259.             // /nsm/client/session_is_loaded

  260.         }

  261. 

  262. #ifndef BUILD_ANSI_TEST

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

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

  265. #endif

  266. 

  267.         lo_address_free(addr);

  268.     }

  269. 

  270.     void idle() noexcept

  271.     {

  272.         if (fOscServer == nullptr)

  273.             return;

  274. 

  275.         for (;;)

  276.         {

  277.             try {

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

  279.                     break;

  280.             }

  281.             CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  282.         }

  283.     }

  284. 

  285. protected:

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

  287.     {

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

  289. 

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

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

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

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

  294. 

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

  296. 

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

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

  299. 

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

  301. 

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

  303. 

  304.         return 0;

  305. 

  306. #ifndef DEBUG

  307.         // unused

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

  309. #endif

  310.     }

  311. 

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

  313.     {

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

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

  316. 

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

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

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

  320. 

  321.         if (! carla_is_engine_running())

  322.         {

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

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

  325. 

  326.             carla_engine_init("JACK", clientId);

  327.         }

  328.         else

  329.         {

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

  331. 

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

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

  334.         }

  335. 

  336.         fClientId = clientId;

  337. 

  338.         fProjectPath  = projectPath;

  339.         fProjectPath += ".carxp";

  340. 

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

  342. 

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

  344. 

  345. #ifndef BUILD_ANSI_TEST

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

  347. #endif

  348. 

  349. #if 0

  350.         if (fHasBroadcast)

  351.         {

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

  353. 

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

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

  356. 

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

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

  359. 

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

  361. 

  362.             std::free(url);

  363. 

  364.             carla_stdout("Broadcast sent!");

  365.         }

  366.         else

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

  368. #endif

  369. 

  370.         return 0;

  371. 

  372. #ifndef DEBUG

  373.         // unused

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

  375. #endif

  376.     }

  377. 

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

  379.     {

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

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

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

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

  384. 

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

  386. 

  387. #ifndef BUILD_ANSI_TEST

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

  389. #endif

  390. 

  391.         return 0;

  392. 

  393. #ifndef DEBUG

  394.         // unused

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

  396. #endif

  397.     }

  398. 

  399. #if 0

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

  401.     {

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

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

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

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

  406. 

  407. #ifdef HAVE_X11

  408. #endif

  409. 

  410. #ifndef BUILD_ANSI_TEST

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

  412. #endif

  413. 

  414.         return 0;

  415.     }

  416. #endif

  417. 

  418. private:

  419.     lo_server fOscServer;

  420. 

  421.     CarlaString fClientId;

  422.     CarlaString fProjectPath;

  423. 

  424.     bool fHasBroadcast;

  425.     bool fHasShowHideUI;

  426. 

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

  428. 

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

  430.     {

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

  432.     }

  433. 

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

  435.     {

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

  437.     }

  438. 

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

  440.     {

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

  442.     }

  443. 

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

  445.     {

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

  447.     }

  448. 

  449. #if 0

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

  451.     {

  452.         return handlePtr->handleShowHideGui(true);

  453.     }

  454. 

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

  456.     {

  457.         return handlePtr->handleShowHideGui(false);

  458.     }

  459. #endif

  460. 

  461.     #undef handlePtr

  462. 

  463.     CARLA_PREVENT_HEAP_ALLOCATION

  464.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  465. };

  466. 

  467. static CarlaNSM gNSM;

  468. 

  469. // -------------------------------------------------------------------------------------------------------------------

  470. // Always return a valid string ptr

  471. 

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

  473. 

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

  475. {

  476.     if (charPtr == nullptr)

  477.         charPtr = gNullCharPtr;

  478. }

  479. 

  480. // -------------------------------------------------------------------------------------------------------------------

  481. // Constructors

  482. 

  483. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  484.     : type(CB::PLUGIN_NONE),

  485.       category(CB::PLUGIN_CATEGORY_NONE),

  486.       hints(0x0),

  487.       optionsAvailable(0x0),

  488.       optionsEnabled(0x0),

  489.       filename(gNullCharPtr),

  490.       name(gNullCharPtr),

  491.       label(gNullCharPtr),

  492.       maker(gNullCharPtr),

  493.       copyright(gNullCharPtr),

  494.       iconName(gNullCharPtr),

  495.       uniqueId(0) {}

  496. 

  497. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  498. {

  499.     if (label != gNullCharPtr)

  500.         delete[] label;

  501.     if (maker != gNullCharPtr)

  502.         delete[] maker;

  503.     if (copyright != gNullCharPtr)

  504.         delete[] copyright;

  505. }

  506. 

  507. _CarlaNativePluginInfo::_CarlaNativePluginInfo() noexcept

  508.     : category(CB::PLUGIN_CATEGORY_NONE),

  509.       hints(0x0),

  510.       audioIns(0),

  511.       audioOuts(0),

  512.       midiIns(0),

  513.       midiOuts(0),

  514.       parameterIns(0),

  515.       parameterOuts(0),

  516.       name(gNullCharPtr),

  517.       label(gNullCharPtr),

  518.       maker(gNullCharPtr),

  519.       copyright(gNullCharPtr) {}

  520. 

  521. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  522.     : name(gNullCharPtr),

  523.       symbol(gNullCharPtr),

  524.       unit(gNullCharPtr),

  525.       scalePointCount(0) {}

  526. 

  527. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  528. {

  529.     if (name != gNullCharPtr)

  530.         delete[] name;

  531.     if (symbol != gNullCharPtr)

  532.         delete[] symbol;

  533.     if (unit != gNullCharPtr)

  534.         delete[] unit;

  535. }

  536. 

  537. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  538.     : value(0.0f),

  539.       label(gNullCharPtr) {}

  540. 

  541. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  542. {

  543.     if (label != gNullCharPtr)

  544.         delete[] label;

  545. }

  546. 

  547. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  548.     : playing(false),

  549.       frame(0),

  550.       bar(0),

  551.       beat(0),

  552.       tick(0),

  553.       bpm(0.0) {}

  554. 

  555. // -------------------------------------------------------------------------------------------------------------------

  556. // API

  557. 

  558. const char* carla_get_complete_license_text()

  559. {

  560.     carla_debug("carla_get_complete_license_text()");

  561. 

  562.     static CarlaString retText;

  563. 

  564.     if (retText.isEmpty())

  565.     {

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

  567. 

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

  569.         text1 += "<ul>";

  570. 

  571.         // Plugin formats

  572. #ifdef WANT_LADSPA

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

  574. #endif

  575. #ifdef WANT_DSSI

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

  577. #endif

  578. #ifdef WANT_LV2

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

  580. #endif

  581. #ifdef WANT_VST

  582. # ifdef VESTIGE_HEADER

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

  584. # else

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

  586. # endif

  587. #endif

  588. #ifdef WANT_AU

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

  590. #endif

  591. 

  592.         // Files

  593. #ifdef WANT_CSOUND

  594.         text2 += "<li>CSound library for csd support</li>"; // FIXME

  595. #endif

  596. 

  597.         // Sample kit libraries

  598. #ifdef WANT_FLUIDSYNTH

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

  600. #endif

  601. #ifdef WANT_LINUXSAMPLER

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

  603. #endif

  604. 

  605. #ifdef WANT_NATIVE

  606.         // Internal plugins

  607. # ifdef HAVE_OPENGL

  608.         text3 += "<li>DISTRHO Mini-Series plugin code, based on LOSER-dev suite by Michael Gruhn</li>";

  609. # endif

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

  611.         //text1 += "<li>SunVox library file support, http://www.warmplace.ru/soft/sunvox/</li>"; // unfinished

  612. # ifdef WANT_AUDIOFILE

  613.         text3 += "<li>AudioDecoder library for Audio file support, by Robin Gareus</li>";

  614. # endif

  615. # ifdef WANT_MIDIFILE

  616.         text3 += "<li>LibSMF library for MIDI file support, http://libsmf.sourceforge.net/</li>";

  617. # endif

  618. # ifdef WANT_ZYNADDSUBFX

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

  620. #  ifdef WANT_ZYNADDSUBFX_UI

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

  622. #  endif

  623. # endif

  624. #endif

  625. 

  626.         // misc libs

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

  628. #ifdef WANT_LV2

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

  630. #endif

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

  632. 

  633.         // end

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

  635. 

  636.         // code snippets

  637.         text5 += "<p>Additionally, Carla uses code snippets from the following projects:</p>";

  638.         text5 += "<ul>";

  639.         text5 += "<li>Pointer and data leak utils from JUCE, http://www.rawmaterialsoftware.com/juce.php</li>";

  640.         text5 += "<li>Shared memory utils from dssi-vst, http://www.breakfastquay.com/dssi-vst/</li>";

  641.         text5 += "<li>Real-time memory pool, by Nedko Arnaudov</li>";

  642.         text5 += "</ul>";

  643. 

  644. #ifdef WANT_LINUXSAMPLER

  645.         // LinuxSampler GPL exception

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

  647. #endif

  648. 

  649.         retText = text1 + text2 + text3 + text4 + text5;

  650.     }

  651. 

  652.     return retText;

  653. }

  654. 

  655. const char* carla_get_supported_file_extensions()

  656. {

  657.     carla_debug("carla_get_supported_file_extensions()");

  658. 

  659.     static CarlaString retText;

  660. 

  661.     if (retText.isEmpty())

  662.     {

  663.         // Base types

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

  665. 

  666.         // CSound

  667. #ifdef WANT_CSOUND

  668.         retText += ";*.csd";

  669. #endif

  670. 

  671.         // Sample kits

  672. #ifdef WANT_FLUIDSYNTH

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

  674. #endif

  675. #ifdef WANT_LINUXSAMPLER

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

  677. #endif

  678. 

  679.         // Files provided by internal plugins

  680. #ifdef WANT_AUDIOFILE

  681.         retText += ";*.aiff;*.flac;*.oga;*.ogg;*.w64;*.wav";

  682. # ifdef HAVE_FFMPEG

  683.         retText += ";*.3g2;*.3gp;*.aac;*.ac3;*.amr;*.ape;*.mp2;*.mp3;*.mpc;*.wma";

  684. # endif

  685. #endif

  686. #ifdef WANT_MIDIFILE

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

  688. #endif

  689. 

  690.         // Plugin presets

  691. #ifdef WANT_ZYNADDSUBFX

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

  693. #endif

  694.     }

  695. 

  696.     return retText;

  697. }

  698. 

  699. // -------------------------------------------------------------------------------------------------------------------

  700. 

  701. unsigned int carla_get_engine_driver_count()

  702. {

  703.     carla_debug("carla_get_engine_driver_count()");

  704. 

  705.     return CarlaEngine::getDriverCount();

  706. }

  707. 

  708. const char* carla_get_engine_driver_name(unsigned int index)

  709. {

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

  711. 

  712.     return CarlaEngine::getDriverName(index);

  713. }

  714. 

  715. const char* const* carla_get_engine_driver_device_names(unsigned int index)

  716. {

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

  718. 

  719.     return CarlaEngine::getDriverDeviceNames(index);

  720. }

  721. 

  722. const EngineDriverDeviceInfo* carla_get_engine_driver_device_info(unsigned int index, const char* name)

  723. {

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

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

  726. 

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

  728.     {

  729.         static EngineDriverDeviceInfo devInfo;

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

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

  732. 

  733.         devInfo.hints       = ret->hints;

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

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

  736.         return &devInfo;

  737.     }

  738. 

  739.     return nullptr;

  740. }

  741. 

  742. // -------------------------------------------------------------------------------------------------------------------

  743. 

  744. unsigned int carla_get_internal_plugin_count()

  745. {

  746.     carla_debug("carla_get_internal_plugin_count()");

  747. 

  748. #ifdef WANT_NATIVE

  749.     return static_cast<unsigned int>(CarlaPlugin::getNativePluginCount());

  750. #else

  751.     return 0;

  752. #endif

  753. }

  754. 

  755. const CarlaNativePluginInfo* carla_get_internal_plugin_info(unsigned int index)

  756. {

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

  758. 

  759. #ifdef WANT_NATIVE

  760.     static CarlaNativePluginInfo info;

  761. 

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

  763. 

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

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

  766. 

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

  768.      info.hints    = 0x0;

  769. 

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

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

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

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

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

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

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

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

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

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

  780. 

  781.      info.audioIns  = nativePlugin->audioIns;

  782.      info.audioOuts = nativePlugin->audioOuts;

  783.      info.midiIns   = nativePlugin->midiIns;

  784.      info.midiOuts  = nativePlugin->midiOuts;

  785.      info.parameterIns  = nativePlugin->paramIns;

  786.      info.parameterOuts = nativePlugin->paramOuts;

  787. 

  788.      info.name      = nativePlugin->name;

  789.      info.label     = nativePlugin->label;

  790.      info.maker     = nativePlugin->maker;

  791.      info.copyright = nativePlugin->copyright;

  792. 

  793.      checkStringPtr(info.name);

  794.      checkStringPtr(info.label);

  795.      checkStringPtr(info.maker);

  796.      checkStringPtr(info.copyright);

  797. 

  798.     return &info;

  799. #else

  800.     return nullptr;

  801. 

  802.     // unused

  803.     (void)index;

  804. #endif

  805. }

  806. 

  807. // -------------------------------------------------------------------------------------------------------------------

  808. 

  809. const CarlaEngine* carla_get_engine()

  810. {

  811.     carla_debug("carla_get_engine()");

  812. 

  813.     return gStandalone.engine;

  814. }

  815. 

  816. // -------------------------------------------------------------------------------------------------------------------

  817. 

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

  819. {

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

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

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

  823. 

  824.     if (gStandalone.engine != nullptr)

  825.     {

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

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

  828.         return false;

  829.     }

  830. 

  831. #ifdef CARLA_OS_WIN

  832.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  833. #endif

  834. 

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

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

  837.     {

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

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

  840.     }

  841. 

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

  843. 

  844.     if (gStandalone.engine == nullptr)

  845.     {

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

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

  848.         return false;

  849.     }

  850. 

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

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

  853. 

  854. #ifdef BUILD_BRIDGE

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

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

  857. #else

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

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

  860. #endif

  861. 

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

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

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

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

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

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

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

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

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

  871. 

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

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

  874. 

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

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

  877. 

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

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

  880. 

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

  882.     {

  883.         char strBuf[STR_MAX+1];

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

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

  886.     }

  887.     else

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

  889. 

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

  891.     {

  892.         gStandalone.lastError = "No error";

  893. #ifdef HAVE_JUCE

  894.         gStandalone.init();

  895. #endif

  896.         return true;

  897.     }

  898.     else

  899.     {

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

  901.         delete gStandalone.engine;

  902.         gStandalone.engine = nullptr;

  903.         return false;

  904.     }

  905. }

  906. 

  907. #ifdef BUILD_BRIDGE

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

  909. {

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

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

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

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

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

  915. 

  916.     if (gStandalone.engine != nullptr)

  917.     {

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

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

  920.         return false;

  921.     }

  922. 

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

  924. 

  925.     if (gStandalone.engine == nullptr)

  926.     {

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

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

  929.         return false;

  930.     }

  931. 

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

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

  934. 

  935.     // forced options for bridge mode

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

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

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

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

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

  941. 

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

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

  944. 

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

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

  947. 

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

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

  950. 

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

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

  953. 

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

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

  956. 

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

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

  959. 

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

  961.     {

  962.         gStandalone.lastError = "No error";

  963. #ifdef HAVE_JUCE

  964.         gStandalone.init();

  965. #endif

  966.         return true;

  967.     }

  968.     else

  969.     {

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

  971.         delete gStandalone.engine;

  972.         gStandalone.engine = nullptr;

  973.         return false;

  974.     }

  975. }

  976. #endif

  977. 

  978. bool carla_engine_close()

  979. {

  980.     carla_debug("carla_engine_close()");

  981. 

  982.     if (gStandalone.engine == nullptr)

  983.     {

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

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

  986.         return false;

  987.     }

  988. 

  989.     gStandalone.engine->setAboutToClose();

  990.     gStandalone.engine->removeAllPlugins();

  991. 

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

  993. 

  994.     if (! closed)

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

  996. 

  997. #ifdef HAVE_JUCE

  998.     gStandalone.close();

  999. #endif

  1000. 

  1001.     delete gStandalone.engine;

  1002.     gStandalone.engine = nullptr;

  1003. 

  1004.     return closed;

  1005. }

  1006. 

  1007. void carla_engine_idle()

  1008. {

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

  1010. 

  1011.     gNSM.idle();

  1012. #if defined(HAVE_JUCE) && ! defined(CARLA_OS_LINUX)

  1013.     gStandalone.idle();

  1014. #endif

  1015.     gStandalone.engine->idle();

  1016. }

  1017. 

  1018. bool carla_is_engine_running()

  1019. {

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

  1021. }

  1022. 

  1023. void carla_set_engine_about_to_close()

  1024. {

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

  1026.     carla_debug("carla_set_engine_about_to_close()");

  1027. 

  1028.     gStandalone.engine->setAboutToClose();

  1029. }

  1030. 

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

  1032. {

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

  1034. 

  1035.     gStandalone.engineCallback    = func;

  1036.     gStandalone.engineCallbackPtr = ptr;

  1037. 

  1038.     if (gStandalone.engine != nullptr)

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

  1040. 

  1041. //#ifdef WANT_LOGS

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

  1043. //#endif

  1044. }

  1045. 

  1046. #ifndef BUILD_BRIDGE

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

  1048. {

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

  1050. 

  1051.     switch (option)

  1052.     {

  1053.     case CB::ENGINE_OPTION_DEBUG:

  1054.         break;

  1055. 

  1056.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  1059.         break;

  1060. 

  1061.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1064.         break;

  1065. 

  1066.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  1069.         break;

  1070. 

  1071.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1074.         break;

  1075. 

  1076.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1079.         break;

  1080. 

  1081.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1084.         break;

  1085. 

  1086.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  1087.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1088.         gStandalone.engineOptions.maxParameters = static_cast<unsigned int>(value);

  1089.         break;

  1090. 

  1091.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1092.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

  1093.         gStandalone.engineOptions.uiBridgesTimeout = static_cast<unsigned int>(value);

  1094.         break;

  1095. 

  1096.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

  1098.         gStandalone.engineOptions.audioNumPeriods = static_cast<unsigned int>(value);

  1099.         break;

  1100. 

  1101.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1102.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

  1103.         gStandalone.engineOptions.audioBufferSize = static_cast<unsigned int>(value);

  1104.         break;

  1105. 

  1106.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1107.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

  1108.         gStandalone.engineOptions.audioSampleRate = static_cast<unsigned int>(value);

  1109.         break;

  1110. 

  1111.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  1112.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1113. 

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

  1115.             delete[] gStandalone.engineOptions.audioDevice;

  1116. 

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

  1118.         break;

  1119. 

  1120.     case CB:: ENGINE_OPTION_NSM_INIT:

  1121.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  1123.         gNSM.announce(value, valueStr);

  1124.         break;

  1125. 

  1126.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  1128. 

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

  1130.             delete[] gStandalone.engineOptions.binaryDir;

  1131. 

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

  1133.         break;

  1134. 

  1135.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  1137. 

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

  1139.             delete[] gStandalone.engineOptions.resourceDir;

  1140. 

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

  1142.         break;

  1143. 

  1144.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1147.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1149.         break;

  1150.     }

  1151. 

  1152.     if (gStandalone.engine != nullptr)

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

  1154. }

  1155. #endif

  1156. 

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

  1158. {

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

  1160. 

  1161.     gStandalone.fileCallback    = func;

  1162.     gStandalone.fileCallbackPtr = ptr;

  1163. 

  1164.     if (gStandalone.engine != nullptr)

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

  1166. }

  1167. 

  1168. // -------------------------------------------------------------------------------------------------------------------

  1169. 

  1170. bool carla_load_file(const char* filename)

  1171. {

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

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

  1174. 

  1175.     if (gStandalone.engine != nullptr)

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

  1177. 

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

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

  1180.     return false;

  1181. }

  1182. 

  1183. bool carla_load_project(const char* filename)

  1184. {

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

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

  1187. 

  1188.     if (gStandalone.engine != nullptr)

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

  1190. 

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

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

  1193.     return false;

  1194. }

  1195. 

  1196. bool carla_save_project(const char* filename)

  1197. {

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

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

  1200. 

  1201.     if (gStandalone.engine != nullptr)

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

  1203. 

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

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

  1206.     return false;

  1207. }

  1208. 

  1209. #ifndef BUILD_BRIDGE

  1210. // -------------------------------------------------------------------------------------------------------------------

  1211. 

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

  1213. {

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

  1215. 

  1216.     if (gStandalone.engine != nullptr)

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

  1218. 

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

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

  1221.     return false;

  1222. }

  1223. 

  1224. bool carla_patchbay_disconnect(uint connectionId)

  1225. {

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

  1227. 

  1228.     if (gStandalone.engine != nullptr)

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

  1230. 

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

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

  1233.     return false;

  1234. }

  1235. 

  1236. bool carla_patchbay_refresh()

  1237. {

  1238.     carla_debug("carla_patchbay_refresh()");

  1239. 

  1240.     if (gStandalone.engine != nullptr)

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

  1242. 

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

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

  1245.     return false;

  1246. }

  1247. #endif

  1248. 

  1249. // -------------------------------------------------------------------------------------------------------------------

  1250. 

  1251. void carla_transport_play()

  1252. {

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

  1254.     carla_debug("carla_transport_play()");

  1255. 

  1256.     gStandalone.engine->transportPlay();

  1257. }

  1258. 

  1259. void carla_transport_pause()

  1260. {

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

  1262.     carla_debug("carla_transport_pause()");

  1263. 

  1264.     gStandalone.engine->transportPause();

  1265. }

  1266. 

  1267. void carla_transport_relocate(uint64_t frame)

  1268. {

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

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

  1271. 

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

  1273. }

  1274. 

  1275. uint64_t carla_get_current_transport_frame()

  1276. {

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

  1278. 

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

  1280.     return timeInfo.frame;

  1281. }

  1282. 

  1283. const CarlaTransportInfo* carla_get_transport_info()

  1284. {

  1285.     static CarlaTransportInfo retInfo;

  1286. 

  1287.     // reset

  1288.     retInfo.playing = false;

  1289.     retInfo.frame   = 0;

  1290.     retInfo.bar     = 0;

  1291.     retInfo.beat    = 0;

  1292.     retInfo.tick    = 0;

  1293.     retInfo.bpm     = 0.0;

  1294. 

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

  1296. 

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

  1298. 

  1299.     retInfo.playing = timeInfo.playing;

  1300.     retInfo.frame   = timeInfo.frame;

  1301. 

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

  1303.     {

  1304.         retInfo.bar  = timeInfo.bbt.bar;

  1305.         retInfo.beat = timeInfo.bbt.beat;

  1306.         retInfo.tick = timeInfo.bbt.tick;

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

  1308.     }

  1309. 

  1310.     return &retInfo;

  1311. }

  1312. 

  1313. // -------------------------------------------------------------------------------------------------------------------

  1314. 

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

  1316. {

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

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

  1319. 

  1320.     if (gStandalone.engine != nullptr)

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

  1322. 

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

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

  1325.     return false;

  1326. }

  1327. 

  1328. bool carla_remove_plugin(uint pluginId)

  1329. {

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

  1331. 

  1332.     if (gStandalone.engine != nullptr)

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

  1334. 

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

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

  1337.     return false;

  1338. }

  1339. 

  1340. bool carla_remove_all_plugins()

  1341. {

  1342.     carla_debug("carla_remove_all_plugins()");

  1343. 

  1344.     if (gStandalone.engine != nullptr)

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

  1346. 

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

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

  1349.     return false;

  1350. }

  1351. 

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

  1353. {

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

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

  1356. 

  1357.     if (gStandalone.engine != nullptr)

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

  1359. 

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

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

  1362.     return nullptr;

  1363. }

  1364. 

  1365. bool carla_clone_plugin(uint pluginId)

  1366. {

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

  1368. 

  1369.     if (gStandalone.engine != nullptr)

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

  1371. 

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

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

  1374.     return false;

  1375. }

  1376. 

  1377. bool carla_replace_plugin(uint pluginId)

  1378. {

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

  1380. 

  1381.     if (gStandalone.engine != nullptr)

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

  1383. 

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

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

  1386.     return false;

  1387. }

  1388. 

  1389. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1390. {

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

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

  1393. 

  1394.     if (gStandalone.engine != nullptr)

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

  1396. 

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

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

  1399.     return false;

  1400. }

  1401. 

  1402. // -------------------------------------------------------------------------------------------------------------------

  1403. 

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

  1405. {

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

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

  1408. 

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

  1410.     {

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

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

  1413.         return false;

  1414.     }

  1415. 

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

  1417.         return plugin->loadStateFromFile(filename);

  1418. 

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

  1420.     return false;

  1421. }

  1422. 

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

  1424. {

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

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

  1427. 

  1428.     if (gStandalone.engine == nullptr)

  1429.     {

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

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

  1432.         return false;

  1433.     }

  1434. 

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

  1436. 

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

  1438.         return plugin->saveStateToFile(filename);

  1439. 

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

  1441.     return false;

  1442. }

  1443. 

  1444. // -------------------------------------------------------------------------------------------------------------------

  1445. 

  1446. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1447. {

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

  1449. 

  1450.     static CarlaPluginInfo info;

  1451. 

  1452.     // reset

  1453.     info.type             = CB::PLUGIN_NONE;

  1454.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1455.     info.hints            = 0x0;

  1456.     info.optionsAvailable = 0x0;

  1457.     info.optionsEnabled   = 0x0;

  1458.     info.filename         = gNullCharPtr;

  1459.     info.name             = gNullCharPtr;

  1460.     info.iconName         = gNullCharPtr;

  1461.     info.uniqueId         = 0;

  1462. 

  1463.     // cleanup

  1464.     if (info.label != gNullCharPtr)

  1465.     {

  1466.         delete[] info.label;

  1467.         info.label = gNullCharPtr;

  1468.     }

  1469. 

  1470.     if (info.maker != gNullCharPtr)

  1471.     {

  1472.         delete[] info.maker;

  1473.         info.maker = gNullCharPtr;

  1474.     }

  1475. 

  1476.     if (info.copyright != gNullCharPtr)

  1477.     {

  1478.         delete[] info.copyright;

  1479.         info.copyright = gNullCharPtr;

  1480.     }

  1481. 

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

  1483. 

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

  1485.     {

  1486.         char strBufLabel[STR_MAX+1];

  1487.         char strBufMaker[STR_MAX+1];

  1488.         char strBufCopyright[STR_MAX+1];

  1489. 

  1490.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1491.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1492.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1493. 

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

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

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

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

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

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

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

  1501. 

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

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

  1504. 

  1505.         plugin->getLabel(strBufLabel);

  1506.         info.label = carla_strdup(strBufLabel);

  1507. 

  1508.         plugin->getMaker(strBufMaker);

  1509.         info.maker = carla_strdup(strBufMaker);

  1510. 

  1511.         plugin->getCopyright(strBufCopyright);

  1512.         info.copyright = carla_strdup(strBufCopyright);

  1513. 

  1514.         checkStringPtr(info.filename);

  1515.         checkStringPtr(info.name);

  1516.         checkStringPtr(info.iconName);

  1517. 

  1518.         return &info;

  1519.     }

  1520. 

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

  1522.     return &info;

  1523. }

  1524. 

  1525. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1526. {

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

  1528. 

  1529.     static CarlaPortCountInfo info;

  1530. 

  1531.     // reset

  1532.     info.ins   = 0;

  1533.     info.outs  = 0;

  1534. 

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

  1536. 

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

  1538.     {

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

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

  1541.         return &info;

  1542.     }

  1543. 

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

  1545.     return &info;

  1546. }

  1547. 

  1548. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1549. {

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

  1551. 

  1552.     static CarlaPortCountInfo info;

  1553. 

  1554.     // reset

  1555.     info.ins   = 0;

  1556.     info.outs  = 0;

  1557. 

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

  1559. 

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

  1561.     {

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

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

  1564.         return &info;

  1565.     }

  1566. 

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

  1568.     return &info;

  1569. }

  1570. 

  1571. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1572. {

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

  1574. 

  1575.     static CarlaPortCountInfo info;

  1576. 

  1577.     // reset

  1578.     info.ins   = 0;

  1579.     info.outs  = 0;

  1580. 

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

  1582. 

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

  1584.     {

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

  1586.         return &info;

  1587.     }

  1588. 

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

  1590.     return &info;

  1591. }

  1592. 

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

  1594. {

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

  1596. 

  1597.     static CarlaParameterInfo info;

  1598. 

  1599.     // reset

  1600.     info.scalePointCount = 0;

  1601. 

  1602.     // cleanup

  1603.     if (info.name != gNullCharPtr)

  1604.     {

  1605.         delete[] info.name;

  1606.         info.name = gNullCharPtr;

  1607.     }

  1608. 

  1609.     if (info.symbol != gNullCharPtr)

  1610.     {

  1611.         delete[] info.symbol;

  1612.         info.symbol = gNullCharPtr;

  1613.     }

  1614. 

  1615.     if (info.unit != gNullCharPtr)

  1616.     {

  1617.         delete[] info.unit;

  1618.         info.unit = gNullCharPtr;

  1619.     }

  1620. 

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

  1622. 

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

  1624.     {

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

  1626.         {

  1627.             char strBufName[STR_MAX+1];

  1628.             char strBufSymbol[STR_MAX+1];

  1629.             char strBufUnit[STR_MAX+1];

  1630. 

  1631.             carla_zeroChar(strBufName, STR_MAX+1);

  1632.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1633.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1634. 

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

  1636. 

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

  1638.             info.name = carla_strdup(strBufName);

  1639. 

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

  1641.             info.symbol = carla_strdup(strBufSymbol);

  1642. 

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

  1644.             info.unit = carla_strdup(strBufUnit);

  1645.         }

  1646.         else

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

  1648. 

  1649.         return &info;

  1650.     }

  1651. 

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

  1653.     return &info;

  1654. }

  1655. 

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

  1657. {

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

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

  1660. 

  1661.     static CarlaScalePointInfo info;

  1662. 

  1663.     // reset

  1664.     info.value = 0.0f;

  1665. 

  1666.     // cleanup

  1667.     if (info.label != gNullCharPtr)

  1668.     {

  1669.         delete[] info.label;

  1670.         info.label = gNullCharPtr;

  1671.     }

  1672. 

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

  1674. 

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

  1676.     {

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

  1678.         {

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

  1680.             {

  1681.                 char strBufLabel[STR_MAX+1];

  1682.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1683. 

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

  1685. 

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

  1687.                 info.label = carla_strdup(strBufLabel);

  1688.             }

  1689.             else

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

  1691.         }

  1692.         else

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

  1694. 

  1695.         return &info;

  1696.     }

  1697. 

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

  1699.     return &info;

  1700. }

  1701. 

  1702. // -------------------------------------------------------------------------------------------------------------------

  1703. 

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

  1705. {

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

  1707. 

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

  1709. 

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

  1711. 

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

  1713.     {

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

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

  1716. 

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

  1718.         return &fallbackParameterData;

  1719.     }

  1720. 

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

  1722.     return &fallbackParameterData;

  1723. }

  1724. 

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

  1726. {

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

  1728. 

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

  1730. 

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

  1732. 

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

  1734.     {

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

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

  1737. 

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

  1739.         return &fallbackParamRanges;

  1740.     }

  1741. 

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

  1743.     return &fallbackParamRanges;

  1744. }

  1745. 

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

  1747. {

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

  1749. 

  1750.     static MidiProgramData midiProgData;

  1751. 

  1752.     // reset

  1753.     midiProgData.bank    = 0;

  1754.     midiProgData.program = 0;

  1755.     midiProgData.name    = gNullCharPtr;

  1756. 

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

  1758. 

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

  1760.     {

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

  1762.         {

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

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

  1765.             checkStringPtr(midiProgData.name);

  1766.             return &midiProgData;

  1767.         }

  1768. 

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

  1770.         return &midiProgData;

  1771.     }

  1772. 

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

  1774.     return &midiProgData;

  1775. }

  1776. 

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

  1778. {

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

  1780. 

  1781.     static CustomData customData;

  1782. 

  1783.     // reset

  1784.     customData.type  = gNullCharPtr;

  1785.     customData.key   = gNullCharPtr;

  1786.     customData.value = gNullCharPtr;

  1787. 

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

  1789. 

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

  1791.     {

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

  1793.         {

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

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

  1796.             checkStringPtr(customData.type);

  1797.             checkStringPtr(customData.key);

  1798.             checkStringPtr(customData.value);

  1799.             return &customData;

  1800.         }

  1801. 

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

  1803.         return &customData;

  1804.     }

  1805. 

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

  1807.     return &customData;

  1808. }

  1809. 

  1810. const char* carla_get_chunk_data(uint pluginId)

  1811. {

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

  1813. 

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

  1815. 

  1816.     static CarlaString chunkData;

  1817. 

  1818.     // cleanup

  1819.     chunkData.clear();

  1820. 

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

  1822.     {

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

  1824.         {

  1825.             void* data = nullptr;

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

  1827. 

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

  1829.             {

  1830.                 chunkData = QByteArray((char*)data, dataSize).toBase64().constData();

  1831. 

  1832.                 return chunkData;

  1833.             }

  1834.             else

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

  1836.         }

  1837.         else

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

  1839. 

  1840.         return nullptr;

  1841.     }

  1842. 

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

  1844.     return nullptr;

  1845. }

  1846. 

  1847. // -------------------------------------------------------------------------------------------------------------------

  1848. 

  1849. uint32_t carla_get_parameter_count(uint pluginId)

  1850. {

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

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

  1853. 

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

  1855.         return plugin->getParameterCount();

  1856. 

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

  1858.     return 0;

  1859. }

  1860. 

  1861. uint32_t carla_get_program_count(uint pluginId)

  1862. {

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

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

  1865. 

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

  1867.         return plugin->getProgramCount();

  1868. 

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

  1870.     return 0;

  1871. }

  1872. 

  1873. uint32_t carla_get_midi_program_count(uint pluginId)

  1874. {

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

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

  1877. 

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

  1879.         return plugin->getMidiProgramCount();

  1880. 

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

  1882.     return 0;

  1883. }

  1884. 

  1885. uint32_t carla_get_custom_data_count(uint pluginId)

  1886. {

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

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

  1889. 

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

  1891.         return plugin->getCustomDataCount();

  1892. 

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

  1894.     return 0;

  1895. }

  1896. 

  1897. // -------------------------------------------------------------------------------------------------------------------

  1898. 

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

  1900. {

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

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

  1903. 

  1904.     static char textBuf[STR_MAX+1];

  1905. 

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

  1907.     {

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

  1909.         {

  1910.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1912.             return textBuf;

  1913.         }

  1914. 

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

  1916.         return nullptr;

  1917.     }

  1918. 

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

  1920.     return nullptr;

  1921. }

  1922. 

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

  1924. {

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

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

  1927. 

  1928.     static char programName[STR_MAX+1];

  1929. 

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

  1931.     {

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

  1933.         {

  1934.             carla_zeroChar(programName, STR_MAX+1);

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

  1936.             return programName;

  1937.         }

  1938. 

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

  1940.         return nullptr;

  1941.     }

  1942. 

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

  1944.     return nullptr;

  1945. }

  1946. 

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

  1948. {

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

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

  1951. 

  1952.     static char midiProgramName[STR_MAX+1];

  1953. 

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

  1955.     {

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

  1957.         {

  1958.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1960.             return midiProgramName;

  1961.         }

  1962. 

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

  1964.         return nullptr;

  1965.     }

  1966. 

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

  1968.     return nullptr;

  1969. }

  1970. 

  1971. const char* carla_get_real_plugin_name(uint pluginId)

  1972. {

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

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

  1975. 

  1976.     static char realPluginName[STR_MAX+1];

  1977. 

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

  1979.     {

  1980.         carla_zeroChar(realPluginName, STR_MAX+1);

  1981.         plugin->getRealName(realPluginName);

  1982.         return realPluginName;

  1983.     }

  1984. 

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

  1986.     return nullptr;

  1987. }

  1988. 

  1989. // -------------------------------------------------------------------------------------------------------------------

  1990. 

  1991. int32_t carla_get_current_program_index(uint pluginId)

  1992. {

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

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

  1995. 

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

  1997.         return plugin->getCurrentProgram();

  1998. 

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

  2000.     return -1;

  2001. }

  2002. 

  2003. int32_t carla_get_current_midi_program_index(uint pluginId)

  2004. {

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

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

  2007. 

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

  2009.         return plugin->getCurrentMidiProgram();

  2010. 

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

  2012.     return -1;

  2013. }

  2014. 

  2015. // -------------------------------------------------------------------------------------------------------------------

  2016. 

  2017. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  2018. {

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

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

  2021. 

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

  2023.     {

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

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

  2026. 

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

  2028.         return 0.0f;

  2029.     }

  2030. 

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

  2032.     return 0.0f;

  2033. }

  2034. 

  2035. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  2036. {

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

  2038. 

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

  2040.     {

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

  2042.             return plugin->getParameterValue(parameterId);

  2043. 

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

  2045.         return 0.0f;

  2046.     }

  2047. 

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

  2049.     return 0.0f;

  2050. }

  2051. 

  2052. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  2053. {

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

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

  2056. 

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

  2058.         return plugin->getInternalParameterValue(parameterId);

  2059. 

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

  2061.     return 0.0f;

  2062. }

  2063. 

  2064. // -------------------------------------------------------------------------------------------------------------------

  2065. 

  2066. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  2067. {

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

  2069. 

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

  2071. }

  2072. 

  2073. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  2074. {

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

  2076. 

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

  2078. }

  2079. 

  2080. // -------------------------------------------------------------------------------------------------------------------

  2081. 

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

  2083. {

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

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

  2086. 

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

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

  2089. 

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

  2091. }

  2092. 

  2093. void carla_set_active(uint pluginId, bool onOff)

  2094. {

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

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

  2097. 

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

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

  2100. 

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

  2102. }

  2103. 

  2104. #ifndef BUILD_BRIDGE

  2105. void carla_set_drywet(uint pluginId, float value)

  2106. {

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

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

  2109. 

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

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

  2112. 

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

  2114. }

  2115. 

  2116. void carla_set_volume(uint pluginId, float value)

  2117. {

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

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

  2120. 

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

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

  2123. 

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

  2125. }

  2126. 

  2127. void carla_set_balance_left(uint pluginId, float value)

  2128. {

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

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

  2131. 

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

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

  2134. 

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

  2136. }

  2137. 

  2138. void carla_set_balance_right(uint pluginId, float value)

  2139. {

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

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

  2142. 

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

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

  2145. 

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

  2147. }

  2148. 

  2149. void carla_set_panning(uint pluginId, float value)

  2150. {

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

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

  2153. 

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

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

  2156. 

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

  2158. }

  2159. #endif

  2160. 

  2161. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  2162. {

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

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

  2165. 

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

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

  2168. 

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

  2170. }

  2171. 

  2172. // -------------------------------------------------------------------------------------------------------------------

  2173. 

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

  2175. {

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

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

  2178. 

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

  2180.     {

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

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

  2183. 

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

  2185.         return;

  2186.     }

  2187. 

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

  2189. }

  2190. 

  2191. #ifndef BUILD_BRIDGE

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

  2193. {

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

  2195.     CARLA_SAFE_ASSERT_RETURN(channel >= MAX_MIDI_CHANNELS,);

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

  2197. 

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

  2199.     {

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

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

  2202. 

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

  2204.         return;

  2205.     }

  2206. 

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

  2208. }

  2209. 

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

  2211. {

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

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

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

  2215. 

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

  2217.     {

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

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

  2220. 

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

  2222.         return;

  2223.     }

  2224. 

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

  2226. }

  2227. #endif

  2228. 

  2229. // -------------------------------------------------------------------------------------------------------------------

  2230. 

  2231. void carla_set_program(uint pluginId, uint32_t programId)

  2232. {

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

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

  2235. 

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

  2237.     {

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

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

  2240. 

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

  2242.         return;

  2243.     }

  2244. 

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

  2246. }

  2247. 

  2248. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2249. {

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

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

  2252. 

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

  2254.     {

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

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

  2257. 

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

  2259.         return;

  2260.     }

  2261. 

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

  2263. }

  2264. 

  2265. // -------------------------------------------------------------------------------------------------------------------

  2266. 

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

  2268. {

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

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

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

  2272.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2274. 

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

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

  2277. 

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

  2279. }

  2280. 

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

  2282. {

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

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

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

  2286. 

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

  2288.     {

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

  2290.             return plugin->setChunkData(chunkData);

  2291. 

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

  2293.         return;

  2294.     }

  2295. 

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

  2297. }

  2298. 

  2299. // -------------------------------------------------------------------------------------------------------------------

  2300. 

  2301. void carla_prepare_for_save(uint pluginId)

  2302. {

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

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

  2305. 

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

  2307.         return plugin->prepareForSave();

  2308. 

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

  2310. }

  2311. 

  2312. void carla_reset_parameters(uint pluginId)

  2313. {

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

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

  2316. 

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

  2318.         return plugin->resetParameters();

  2319. 

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

  2321. }

  2322. 

  2323. void carla_randomize_parameters(uint pluginId)

  2324. {

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

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

  2327. 

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

  2329.         return plugin->randomizeParameters();

  2330. 

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

  2332. }

  2333. 

  2334. #ifndef BUILD_BRIDGE

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

  2336. {

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

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

  2339. 

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

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

  2342. 

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

  2344. }

  2345. #endif

  2346. 

  2347. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2348. {

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

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

  2351. 

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

  2353.         return plugin->showCustomUI(yesNo);

  2354. 

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

  2356. }

  2357. 

  2358. // -------------------------------------------------------------------------------------------------------------------

  2359. 

  2360. uint32_t carla_get_buffer_size()

  2361. {

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

  2363.     carla_debug("carla_get_buffer_size()");

  2364. 

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

  2366. }

  2367. 

  2368. double carla_get_sample_rate()

  2369. {

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

  2371.     carla_debug("carla_get_sample_rate()");

  2372. 

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

  2374. }

  2375. 

  2376. // -------------------------------------------------------------------------------------------------------------------

  2377. 

  2378. const char* carla_get_last_error()

  2379. {

  2380.     carla_debug("carla_get_last_error()");

  2381. 

  2382.     if (gStandalone.engine != nullptr)

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

  2384. 

  2385.     return gStandalone.lastError;

  2386. }

  2387. 

  2388. const char* carla_get_host_osc_url_tcp()

  2389. {

  2390.     carla_debug("carla_get_host_osc_url_tcp()");

  2391. 

  2392.     if (gStandalone.engine == nullptr)

  2393.     {

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

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

  2396.         return nullptr;

  2397.     }

  2398. 

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

  2400. }

  2401. 

  2402. const char* carla_get_host_osc_url_udp()

  2403. {

  2404.     carla_debug("carla_get_host_osc_url_udp()");

  2405. 

  2406.     if (gStandalone.engine == nullptr)

  2407.     {

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

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

  2410.         return nullptr;

  2411.     }

  2412. 

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

  2414. }

  2415. 

  2416. // -------------------------------------------------------------------------------------------------------------------

  2417. 

  2418. #ifdef WANT_DSSI

  2419. # include "CarlaDssiUtils.cpp"

  2420. #endif

  2421. 

  2422. #include "CarlaStateUtils.cpp"

  2423. 

  2424. #if 0

  2425. int main(int argc, char* argv[])

  2426. {

  2427.     return 0;

  2428. }

  2429. #endif

  2430. 

  2431. // -------------------------------------------------------------------------------------------------------------------