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.
1901 Commits
16 Branches
14GB
Tree: 717495a42a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '717495a42a'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2431 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. using juce::Thread;

  44. #endif

  45. 

  46. namespace CB = CarlaBackend;

  47. using CB::EngineOptions;

  48. 

  49. // -------------------------------------------------------------------------------------------------------------------

  50. // Juce Message Thread

  51. 

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

  53. 

  54. class JuceMessageThread : public Thread

  55. {

  56. public:

  57.     JuceMessageThread()

  58.       : Thread("JuceMessageThread"),

  59.         fInitialised(false)

  60.     {

  61.     }

  62. 

  63.     ~JuceMessageThread() override

  64.     {

  65.         stop();

  66.     }

  67. 

  68.     void start()

  69.     {

  70.         CARLA_SAFE_ASSERT_RETURN(! fInitialised,);

  71. 

  72.         fInitialised = false;

  73. 

  74.         startThread(7);

  75. 

  76.         while (! fInitialised)

  77.             sleep(1);

  78.     }

  79. 

  80.     void stop()

  81.     {

  82.         signalThreadShouldExit();

  83.         waitForThreadToExit(5000);

  84.     }

  85. 

  86. protected:

  87.     void run() override

  88.     {

  89.         MessageManager* const msgMgr(MessageManager::getInstance());

  90.         CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  91. 

  92.         msgMgr->setCurrentThreadAsMessageThread();

  93.         fInitialised = true;

  94. 

  95.         while ((! threadShouldExit()) && MessageManager::getInstance()->runDispatchLoopUntil(250))

  96.         {}

  97. 

  98.         fInitialised = false;

  99.     }

  100. 

  101. private:

  102.     volatile bool fInitialised;

  103. 

  104.     CARLA_DECLARE_NON_COPY_CLASS(JuceMessageThread)

  105. };

  106. 

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

  108. 

  109. // -------------------------------------------------------------------------------------------------------------------

  110. // Single, standalone engine

  111. 

  112. struct CarlaBackendStandalone {

  113.     CarlaEngine*       engine;

  114.     EngineCallbackFunc engineCallback;

  115.     void*              engineCallbackPtr;

  116.     EngineOptions      engineOptions;

  117. 

  118.     FileCallbackFunc fileCallback;

  119.     void*            fileCallbackPtr;

  120. 

  121.     CarlaString lastError;

  122. 

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

  124.     JuceMessageThread juceMsgThread;

  125. #endif

  126. 

  127.     CarlaBackendStandalone()

  128.         : engine(nullptr),

  129.           engineCallback(nullptr),

  130.           engineCallbackPtr(nullptr),

  131.           fileCallback(nullptr),

  132.           fileCallbackPtr(nullptr)

  133.     {

  134. #ifdef BUILD_BRIDGE

  135.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  136.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  137.         engineOptions.forceStereo         = false;

  138.         engineOptions.preferPluginBridges = false;

  139.         engineOptions.preferUiBridges     = false;

  140. #else

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

  142.             return;

  143. 

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

  145. #endif

  146.     }

  147. 

  148.     ~CarlaBackendStandalone()

  149.     {

  150.         CARLA_SAFE_ASSERT(engine == nullptr);

  151. #ifdef HAVE_JUCE

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

  153. #endif

  154.     }

  155. 

  156. #ifdef HAVE_JUCE

  157.     void init()

  158.     {

  159.         JUCE_AUTORELEASEPOOL

  160.         {

  161.             initialiseJuce_GUI();

  162. # ifdef CARLA_OS_LINUX

  163.             juceMsgThread.start();

  164. # else

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

  166.                 msgMgr->setCurrentThreadAsMessageThread();

  167. # endif

  168.         }

  169.     }

  170. 

  171.     void close()

  172.     {

  173.         JUCE_AUTORELEASEPOOL

  174.         {

  175. # ifdef CARLA_OS_LINUX

  176.             juceMsgThread.stop();

  177. # else

  178.             MessageManager::deleteInstance();

  179. # endif

  180.             shutdownJuce_GUI();

  181.         }

  182.     }

  183. 

  184. # ifndef CARLA_OS_LINUX

  185.     void idle()

  186.     {

  187.         JUCE_AUTORELEASEPOOL

  188.         {

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

  190.                 msgMgr->runDispatchLoopUntil(5);

  191.         }

  192.     }

  193. # endif

  194. #endif

  195. 

  196.     CARLA_PREVENT_HEAP_ALLOCATION

  197.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  198. };

  199. 

  200. static CarlaBackendStandalone gStandalone;

  201. 

  202. // -------------------------------------------------------------------------------------------------------------------

  203. // NSM support

  204. 

  205. #define NSM_API_VERSION_MAJOR 1

  206. #define NSM_API_VERSION_MINOR 2

  207. 

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

  209. #define NSM_CLIENT_FEATURES ":switch:"

  210. 

  211. class CarlaNSM

  212. {

  213. public:

  214.     CarlaNSM() noexcept

  215.         : fOscServer(nullptr),

  216.           fHasBroadcast(false),

  217.           fHasShowHideUI(false) {}

  218. 

  219.     ~CarlaNSM()

  220.     {

  221.         if (fOscServer != nullptr)

  222.         {

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

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

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

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

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

  228.             lo_server_free(fOscServer);

  229.             fOscServer = nullptr;

  230.         }

  231.     }

  232. 

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

  234.     {

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

  236. 

  237.         if (NSM_URL == nullptr)

  238.             return;

  239. 

  240.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  241. 

  242.         if (addr == nullptr)

  243.             return;

  244. 

  245.         const int proto = lo_address_get_protocol(addr);

  246. 

  247.         if (fOscServer == nullptr)

  248.         {

  249.             // create new OSC server

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

  251. 

  252.             // register message handlers and start OSC thread

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

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

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

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

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

  258.             // /nsm/client/session_is_loaded

  259.         }

  260. 

  261. #ifndef BUILD_ANSI_TEST

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

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

  264. #endif

  265. 

  266.         lo_address_free(addr);

  267.     }

  268. 

  269.     void idle() noexcept

  270.     {

  271.         if (fOscServer == nullptr)

  272.             return;

  273. 

  274.         for (;;)

  275.         {

  276.             try {

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

  278.                     break;

  279.             }

  280.             CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  281.         }

  282.     }

  283. 

  284. protected:

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

  286.     {

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

  288. 

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

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

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

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

  293. 

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

  295. 

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

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

  298. 

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

  300. 

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

  302. 

  303.         return 0;

  304. 

  305. #ifndef DEBUG

  306.         // unused

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

  308. #endif

  309.     }

  310. 

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

  312.     {

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

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

  315. 

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

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

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

  319. 

  320.         if (! carla_is_engine_running())

  321.         {

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

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

  324. 

  325.             carla_engine_init("JACK", clientId);

  326.         }

  327.         else

  328.         {

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

  330. 

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

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

  333.         }

  334. 

  335.         fClientId = clientId;

  336. 

  337.         fProjectPath  = projectPath;

  338.         fProjectPath += ".carxp";

  339. 

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

  341. 

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

  343. 

  344. #ifndef BUILD_ANSI_TEST

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

  346. #endif

  347. 

  348. #if 0

  349.         if (fHasBroadcast)

  350.         {

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

  352. 

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

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

  355. 

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

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

  358. 

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

  360. 

  361.             std::free(url);

  362. 

  363.             carla_stdout("Broadcast sent!");

  364.         }

  365.         else

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

  367. #endif

  368. 

  369.         return 0;

  370. 

  371. #ifndef DEBUG

  372.         // unused

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

  374. #endif

  375.     }

  376. 

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

  378.     {

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

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

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

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

  383. 

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

  385. 

  386. #ifndef BUILD_ANSI_TEST

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

  388. #endif

  389. 

  390.         return 0;

  391. 

  392. #ifndef DEBUG

  393.         // unused

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

  395. #endif

  396.     }

  397. 

  398. #if 0

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

  400.     {

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

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

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

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

  405. 

  406. #ifdef HAVE_X11

  407. #endif

  408. 

  409. #ifndef BUILD_ANSI_TEST

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

  411. #endif

  412. 

  413.         return 0;

  414.     }

  415. #endif

  416. 

  417. private:

  418.     lo_server fOscServer;

  419. 

  420.     CarlaString fClientId;

  421.     CarlaString fProjectPath;

  422. 

  423.     bool fHasBroadcast;

  424.     bool fHasShowHideUI;

  425. 

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

  427. 

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

  429.     {

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

  431.     }

  432. 

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

  434.     {

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

  436.     }

  437. 

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

  439.     {

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

  441.     }

  442. 

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

  444.     {

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

  446.     }

  447. 

  448. #if 0

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

  450.     {

  451.         return handlePtr->handleShowHideGui(true);

  452.     }

  453. 

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

  455.     {

  456.         return handlePtr->handleShowHideGui(false);

  457.     }

  458. #endif

  459. 

  460.     #undef handlePtr

  461. 

  462.     CARLA_PREVENT_HEAP_ALLOCATION

  463.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  464. };

  465. 

  466. static CarlaNSM gNSM;

  467. 

  468. // -------------------------------------------------------------------------------------------------------------------

  469. // Always return a valid string ptr

  470. 

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

  472. 

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

  474. {

  475.     if (charPtr == nullptr)

  476.         charPtr = gNullCharPtr;

  477. }

  478. 

  479. // -------------------------------------------------------------------------------------------------------------------

  480. // Constructors

  481. 

  482. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  483.     : type(CB::PLUGIN_NONE),

  484.       category(CB::PLUGIN_CATEGORY_NONE),

  485.       hints(0x0),

  486.       optionsAvailable(0x0),

  487.       optionsEnabled(0x0),

  488.       filename(gNullCharPtr),

  489.       name(gNullCharPtr),

  490.       label(gNullCharPtr),

  491.       maker(gNullCharPtr),

  492.       copyright(gNullCharPtr),

  493.       iconName(gNullCharPtr),

  494.       uniqueId(0) {}

  495. 

  496. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  497. {

  498.     if (label != gNullCharPtr)

  499.         delete[] label;

  500.     if (maker != gNullCharPtr)

  501.         delete[] maker;

  502.     if (copyright != gNullCharPtr)

  503.         delete[] copyright;

  504. }

  505. 

  506. _CarlaNativePluginInfo::_CarlaNativePluginInfo() noexcept

  507.     : category(CB::PLUGIN_CATEGORY_NONE),

  508.       hints(0x0),

  509.       audioIns(0),

  510.       audioOuts(0),

  511.       midiIns(0),

  512.       midiOuts(0),

  513.       parameterIns(0),

  514.       parameterOuts(0),

  515.       name(gNullCharPtr),

  516.       label(gNullCharPtr),

  517.       maker(gNullCharPtr),

  518.       copyright(gNullCharPtr) {}

  519. 

  520. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  521.     : name(gNullCharPtr),

  522.       symbol(gNullCharPtr),

  523.       unit(gNullCharPtr),

  524.       scalePointCount(0) {}

  525. 

  526. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  527. {

  528.     if (name != gNullCharPtr)

  529.         delete[] name;

  530.     if (symbol != gNullCharPtr)

  531.         delete[] symbol;

  532.     if (unit != gNullCharPtr)

  533.         delete[] unit;

  534. }

  535. 

  536. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  537.     : value(0.0f),

  538.       label(gNullCharPtr) {}

  539. 

  540. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  541. {

  542.     if (label != gNullCharPtr)

  543.         delete[] label;

  544. }

  545. 

  546. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  547.     : playing(false),

  548.       frame(0),

  549.       bar(0),

  550.       beat(0),

  551.       tick(0),

  552.       bpm(0.0) {}

  553. 

  554. // -------------------------------------------------------------------------------------------------------------------

  555. // API

  556. 

  557. const char* carla_get_complete_license_text()

  558. {

  559.     carla_debug("carla_get_complete_license_text()");

  560. 

  561.     static CarlaString retText;

  562. 

  563.     if (retText.isEmpty())

  564.     {

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

  566. 

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

  568.         text1 += "<ul>";

  569. 

  570.         // Plugin formats

  571. #ifdef WANT_LADSPA

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

  573. #endif

  574. #ifdef WANT_DSSI

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

  576. #endif

  577. #ifdef WANT_LV2

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

  579. #endif

  580. #ifdef WANT_VST

  581. # ifdef VESTIGE_HEADER

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

  583. # else

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

  585. # endif

  586. #endif

  587. #ifdef WANT_AU

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

  589. #endif

  590. 

  591.         // Files

  592. #ifdef WANT_CSOUND

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

  594. #endif

  595. 

  596.         // Sample kit libraries

  597. #ifdef WANT_FLUIDSYNTH

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

  599. #endif

  600. #ifdef WANT_LINUXSAMPLER

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

  602. #endif

  603. 

  604. #ifdef WANT_NATIVE

  605.         // Internal plugins

  606. # ifdef HAVE_OPENGL

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

  608. # endif

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

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

  611. # ifdef WANT_AUDIOFILE

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

  613. # endif

  614. # ifdef WANT_MIDIFILE

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

  616. # endif

  617. # ifdef WANT_ZYNADDSUBFX

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

  619. #  ifdef WANT_ZYNADDSUBFX_UI

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

  621. #  endif

  622. # endif

  623. #endif

  624. 

  625.         // misc libs

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

  627. #ifdef WANT_LV2

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

  629. #endif

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

  631. 

  632.         // end

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

  634. 

  635.         // code snippets

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

  637.         text5 += "<ul>";

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

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

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

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

  642. 

  643. #ifdef WANT_LINUXSAMPLER

  644.         // LinuxSampler GPL exception

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

  646. #endif

  647. 

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

  649.     }

  650. 

  651.     return retText;

  652. }

  653. 

  654. const char* carla_get_supported_file_extensions()

  655. {

  656.     carla_debug("carla_get_supported_file_extensions()");

  657. 

  658.     static CarlaString retText;

  659. 

  660.     if (retText.isEmpty())

  661.     {

  662.         // Base types

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

  664. 

  665.         // CSound

  666. #ifdef WANT_CSOUND

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

  668. #endif

  669. 

  670.         // Sample kits

  671. #ifdef WANT_FLUIDSYNTH

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

  673. #endif

  674. #ifdef WANT_LINUXSAMPLER

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

  676. #endif

  677. 

  678.         // Files provided by internal plugins

  679. #ifdef WANT_AUDIOFILE

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

  681. # ifdef HAVE_FFMPEG

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

  683. # endif

  684. #endif

  685. #ifdef WANT_MIDIFILE

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

  687. #endif

  688. 

  689.         // Plugin presets

  690. #ifdef WANT_ZYNADDSUBFX

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

  692. #endif

  693.     }

  694. 

  695.     return retText;

  696. }

  697. 

  698. // -------------------------------------------------------------------------------------------------------------------

  699. 

  700. unsigned int carla_get_engine_driver_count()

  701. {

  702.     carla_debug("carla_get_engine_driver_count()");

  703. 

  704.     return CarlaEngine::getDriverCount();

  705. }

  706. 

  707. const char* carla_get_engine_driver_name(unsigned int index)

  708. {

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

  710. 

  711.     return CarlaEngine::getDriverName(index);

  712. }

  713. 

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

  715. {

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

  717. 

  718.     return CarlaEngine::getDriverDeviceNames(index);

  719. }

  720. 

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

  722. {

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

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

  725. 

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

  727.     {

  728.         static EngineDriverDeviceInfo devInfo;

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

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

  731. 

  732.         devInfo.hints       = ret->hints;

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

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

  735.         return &devInfo;

  736.     }

  737. 

  738.     return nullptr;

  739. }

  740. 

  741. // -------------------------------------------------------------------------------------------------------------------

  742. 

  743. unsigned int carla_get_internal_plugin_count()

  744. {

  745.     carla_debug("carla_get_internal_plugin_count()");

  746. 

  747. #ifdef WANT_NATIVE

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

  749. #else

  750.     return 0;

  751. #endif

  752. }

  753. 

  754. const CarlaNativePluginInfo* carla_get_internal_plugin_info(unsigned int index)

  755. {

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

  757. 

  758. #ifdef WANT_NATIVE

  759.     static CarlaNativePluginInfo info;

  760. 

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

  762. 

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

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

  765. 

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

  767.      info.hints    = 0x0;

  768. 

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

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

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

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

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

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

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

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

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

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

  779. 

  780.      info.audioIns  = nativePlugin->audioIns;

  781.      info.audioOuts = nativePlugin->audioOuts;

  782.      info.midiIns   = nativePlugin->midiIns;

  783.      info.midiOuts  = nativePlugin->midiOuts;

  784.      info.parameterIns  = nativePlugin->paramIns;

  785.      info.parameterOuts = nativePlugin->paramOuts;

  786. 

  787.      info.name      = nativePlugin->name;

  788.      info.label     = nativePlugin->label;

  789.      info.maker     = nativePlugin->maker;

  790.      info.copyright = nativePlugin->copyright;

  791. 

  792.      checkStringPtr(info.name);

  793.      checkStringPtr(info.label);

  794.      checkStringPtr(info.maker);

  795.      checkStringPtr(info.copyright);

  796. 

  797.     return &info;

  798. #else

  799.     return nullptr;

  800. 

  801.     // unused

  802.     (void)index;

  803. #endif

  804. }

  805. 

  806. // -------------------------------------------------------------------------------------------------------------------

  807. 

  808. const CarlaEngine* carla_get_engine()

  809. {

  810.     carla_debug("carla_get_engine()");

  811. 

  812.     return gStandalone.engine;

  813. }

  814. 

  815. // -------------------------------------------------------------------------------------------------------------------

  816. 

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

  818. {

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

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

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

  822. 

  823.     if (gStandalone.engine != nullptr)

  824.     {

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

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

  827.         return false;

  828.     }

  829. 

  830. #ifdef CARLA_OS_WIN

  831.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  832. #endif

  833. 

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

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

  836.     {

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

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

  839.     }

  840. 

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

  842. 

  843.     if (gStandalone.engine == nullptr)

  844.     {

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

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

  847.         return false;

  848.     }

  849. 

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

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

  852. 

  853. #ifdef BUILD_BRIDGE

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

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

  856. #else

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

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

  859. #endif

  860. 

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

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

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

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

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

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

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

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

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

  870. 

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

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

  873. 

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

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

  876. 

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

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

  879. 

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

  881.     {

  882.         char strBuf[STR_MAX+1];

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

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

  885.     }

  886.     else

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

  888. 

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

  890.     {

  891.         gStandalone.lastError = "No error";

  892. #ifdef HAVE_JUCE

  893.         gStandalone.init();

  894. #endif

  895.         return true;

  896.     }

  897.     else

  898.     {

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

  900.         delete gStandalone.engine;

  901.         gStandalone.engine = nullptr;

  902.         return false;

  903.     }

  904. }

  905. 

  906. #ifdef BUILD_BRIDGE

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

  908. {

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

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

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

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

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

  914. 

  915.     if (gStandalone.engine != nullptr)

  916.     {

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

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

  919.         return false;

  920.     }

  921. 

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

  923. 

  924.     if (gStandalone.engine == nullptr)

  925.     {

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

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

  928.         return false;

  929.     }

  930. 

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

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

  933. 

  934.     // forced options for bridge mode

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

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

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

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

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

  940. 

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

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

  943. 

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

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

  946. 

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

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

  949. 

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

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

  952. 

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

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

  955. 

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

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

  958. 

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

  960.     {

  961.         gStandalone.lastError = "No error";

  962. #ifdef HAVE_JUCE

  963.         gStandalone.init();

  964. #endif

  965.         return true;

  966.     }

  967.     else

  968.     {

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

  970.         delete gStandalone.engine;

  971.         gStandalone.engine = nullptr;

  972.         return false;

  973.     }

  974. }

  975. #endif

  976. 

  977. bool carla_engine_close()

  978. {

  979.     carla_debug("carla_engine_close()");

  980. 

  981.     if (gStandalone.engine == nullptr)

  982.     {

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

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

  985.         return false;

  986.     }

  987. 

  988.     gStandalone.engine->setAboutToClose();

  989.     gStandalone.engine->removeAllPlugins();

  990. 

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

  992. 

  993.     if (! closed)

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

  995. 

  996. #ifdef HAVE_JUCE

  997.     gStandalone.close();

  998. #endif

  999. 

  1000.     delete gStandalone.engine;

  1001.     gStandalone.engine = nullptr;

  1002. 

  1003.     return closed;

  1004. }

  1005. 

  1006. void carla_engine_idle()

  1007. {

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

  1009. 

  1010.     gNSM.idle();

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

  1012.     gStandalone.idle();

  1013. #endif

  1014.     gStandalone.engine->idle();

  1015. }

  1016. 

  1017. bool carla_is_engine_running()

  1018. {

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

  1020. }

  1021. 

  1022. void carla_set_engine_about_to_close()

  1023. {

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

  1025.     carla_debug("carla_set_engine_about_to_close()");

  1026. 

  1027.     gStandalone.engine->setAboutToClose();

  1028. }

  1029. 

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

  1031. {

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

  1033. 

  1034.     gStandalone.engineCallback    = func;

  1035.     gStandalone.engineCallbackPtr = ptr;

  1036. 

  1037.     if (gStandalone.engine != nullptr)

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

  1039. 

  1040. //#ifdef WANT_LOGS

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

  1042. //#endif

  1043. }

  1044. 

  1045. #ifndef BUILD_BRIDGE

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

  1047. {

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

  1049. 

  1050.     switch (option)

  1051.     {

  1052.     case CB::ENGINE_OPTION_DEBUG:

  1053.         break;

  1054. 

  1055.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  1058.         break;

  1059. 

  1060.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1063.         break;

  1064. 

  1065.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  1068.         break;

  1069. 

  1070.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1073.         break;

  1074. 

  1075.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1078.         break;

  1079. 

  1080.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1083.         break;

  1084. 

  1085.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  1086.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1088.         break;

  1089. 

  1090.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1091.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1093.         break;

  1094. 

  1095.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1098.         break;

  1099. 

  1100.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1101.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1103.         break;

  1104. 

  1105.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1106.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1108.         break;

  1109. 

  1110.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  1111.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1112. 

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

  1114.             delete[] gStandalone.engineOptions.audioDevice;

  1115. 

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

  1117.         break;

  1118. 

  1119.     case CB:: ENGINE_OPTION_NSM_INIT:

  1120.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  1122.         gNSM.announce(value, valueStr);

  1123.         break;

  1124. 

  1125.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  1127. 

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

  1129.             delete[] gStandalone.engineOptions.binaryDir;

  1130. 

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

  1132.         break;

  1133. 

  1134.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  1136. 

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

  1138.             delete[] gStandalone.engineOptions.resourceDir;

  1139. 

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

  1141.         break;

  1142. 

  1143.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1146.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1148.         break;

  1149.     }

  1150. 

  1151.     if (gStandalone.engine != nullptr)

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

  1153. }

  1154. #endif

  1155. 

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

  1157. {

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

  1159. 

  1160.     gStandalone.fileCallback    = func;

  1161.     gStandalone.fileCallbackPtr = ptr;

  1162. 

  1163.     if (gStandalone.engine != nullptr)

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

  1165. }

  1166. 

  1167. // -------------------------------------------------------------------------------------------------------------------

  1168. 

  1169. bool carla_load_file(const char* filename)

  1170. {

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

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

  1173. 

  1174.     if (gStandalone.engine != nullptr)

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

  1176. 

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

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

  1179.     return false;

  1180. }

  1181. 

  1182. bool carla_load_project(const char* filename)

  1183. {

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

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

  1186. 

  1187.     if (gStandalone.engine != nullptr)

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

  1189. 

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

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

  1192.     return false;

  1193. }

  1194. 

  1195. bool carla_save_project(const char* filename)

  1196. {

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

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

  1199. 

  1200.     if (gStandalone.engine != nullptr)

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

  1202. 

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

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

  1205.     return false;

  1206. }

  1207. 

  1208. #ifndef BUILD_BRIDGE

  1209. // -------------------------------------------------------------------------------------------------------------------

  1210. 

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

  1212. {

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

  1214. 

  1215.     if (gStandalone.engine != nullptr)

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

  1217. 

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

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

  1220.     return false;

  1221. }

  1222. 

  1223. bool carla_patchbay_disconnect(uint connectionId)

  1224. {

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

  1226. 

  1227.     if (gStandalone.engine != nullptr)

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

  1229. 

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

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

  1232.     return false;

  1233. }

  1234. 

  1235. bool carla_patchbay_refresh()

  1236. {

  1237.     carla_debug("carla_patchbay_refresh()");

  1238. 

  1239.     if (gStandalone.engine != nullptr)

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

  1241. 

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

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

  1244.     return false;

  1245. }

  1246. #endif

  1247. 

  1248. // -------------------------------------------------------------------------------------------------------------------

  1249. 

  1250. void carla_transport_play()

  1251. {

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

  1253.     carla_debug("carla_transport_play()");

  1254. 

  1255.     gStandalone.engine->transportPlay();

  1256. }

  1257. 

  1258. void carla_transport_pause()

  1259. {

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

  1261.     carla_debug("carla_transport_pause()");

  1262. 

  1263.     gStandalone.engine->transportPause();

  1264. }

  1265. 

  1266. void carla_transport_relocate(uint64_t frame)

  1267. {

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

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

  1270. 

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

  1272. }

  1273. 

  1274. uint64_t carla_get_current_transport_frame()

  1275. {

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

  1277. 

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

  1279.     return timeInfo.frame;

  1280. }

  1281. 

  1282. const CarlaTransportInfo* carla_get_transport_info()

  1283. {

  1284.     static CarlaTransportInfo retInfo;

  1285. 

  1286.     // reset

  1287.     retInfo.playing = false;

  1288.     retInfo.frame   = 0;

  1289.     retInfo.bar     = 0;

  1290.     retInfo.beat    = 0;

  1291.     retInfo.tick    = 0;

  1292.     retInfo.bpm     = 0.0;

  1293. 

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

  1295. 

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

  1297. 

  1298.     retInfo.playing = timeInfo.playing;

  1299.     retInfo.frame   = timeInfo.frame;

  1300. 

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

  1302.     {

  1303.         retInfo.bar  = timeInfo.bbt.bar;

  1304.         retInfo.beat = timeInfo.bbt.beat;

  1305.         retInfo.tick = timeInfo.bbt.tick;

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

  1307.     }

  1308. 

  1309.     return &retInfo;

  1310. }

  1311. 

  1312. // -------------------------------------------------------------------------------------------------------------------

  1313. 

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

  1315. {

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

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

  1318. 

  1319.     if (gStandalone.engine != nullptr)

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

  1321. 

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

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

  1324.     return false;

  1325. }

  1326. 

  1327. bool carla_remove_plugin(uint pluginId)

  1328. {

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

  1330. 

  1331.     if (gStandalone.engine != nullptr)

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

  1333. 

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

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

  1336.     return false;

  1337. }

  1338. 

  1339. bool carla_remove_all_plugins()

  1340. {

  1341.     carla_debug("carla_remove_all_plugins()");

  1342. 

  1343.     if (gStandalone.engine != nullptr)

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

  1345. 

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

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

  1348.     return false;

  1349. }

  1350. 

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

  1352. {

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

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

  1355. 

  1356.     if (gStandalone.engine != nullptr)

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

  1358. 

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

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

  1361.     return nullptr;

  1362. }

  1363. 

  1364. bool carla_clone_plugin(uint pluginId)

  1365. {

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

  1367. 

  1368.     if (gStandalone.engine != nullptr)

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

  1370. 

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

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

  1373.     return false;

  1374. }

  1375. 

  1376. bool carla_replace_plugin(uint pluginId)

  1377. {

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

  1379. 

  1380.     if (gStandalone.engine != nullptr)

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

  1382. 

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

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

  1385.     return false;

  1386. }

  1387. 

  1388. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1389. {

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

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

  1392. 

  1393.     if (gStandalone.engine != nullptr)

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

  1395. 

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

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

  1398.     return false;

  1399. }

  1400. 

  1401. // -------------------------------------------------------------------------------------------------------------------

  1402. 

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

  1404. {

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

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

  1407. 

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

  1409.     {

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

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

  1412.         return false;

  1413.     }

  1414. 

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

  1416.         return plugin->loadStateFromFile(filename);

  1417. 

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

  1419.     return false;

  1420. }

  1421. 

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

  1423. {

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

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

  1426. 

  1427.     if (gStandalone.engine == nullptr)

  1428.     {

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

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

  1431.         return false;

  1432.     }

  1433. 

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

  1435. 

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

  1437.         return plugin->saveStateToFile(filename);

  1438. 

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

  1440.     return false;

  1441. }

  1442. 

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

  1444. 

  1445. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1446. {

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

  1448. 

  1449.     static CarlaPluginInfo info;

  1450. 

  1451.     // reset

  1452.     info.type             = CB::PLUGIN_NONE;

  1453.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1454.     info.hints            = 0x0;

  1455.     info.optionsAvailable = 0x0;

  1456.     info.optionsEnabled   = 0x0;

  1457.     info.filename         = gNullCharPtr;

  1458.     info.name             = gNullCharPtr;

  1459.     info.iconName         = gNullCharPtr;

  1460.     info.uniqueId         = 0;

  1461. 

  1462.     // cleanup

  1463.     if (info.label != gNullCharPtr)

  1464.     {

  1465.         delete[] info.label;

  1466.         info.label = gNullCharPtr;

  1467.     }

  1468. 

  1469.     if (info.maker != gNullCharPtr)

  1470.     {

  1471.         delete[] info.maker;

  1472.         info.maker = gNullCharPtr;

  1473.     }

  1474. 

  1475.     if (info.copyright != gNullCharPtr)

  1476.     {

  1477.         delete[] info.copyright;

  1478.         info.copyright = gNullCharPtr;

  1479.     }

  1480. 

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

  1482. 

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

  1484.     {

  1485.         char strBufLabel[STR_MAX+1];

  1486.         char strBufMaker[STR_MAX+1];

  1487.         char strBufCopyright[STR_MAX+1];

  1488. 

  1489.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1490.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1491.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1492. 

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

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

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

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

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

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

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

  1500. 

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

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

  1503. 

  1504.         plugin->getLabel(strBufLabel);

  1505.         info.label = carla_strdup(strBufLabel);

  1506. 

  1507.         plugin->getMaker(strBufMaker);

  1508.         info.maker = carla_strdup(strBufMaker);

  1509. 

  1510.         plugin->getCopyright(strBufCopyright);

  1511.         info.copyright = carla_strdup(strBufCopyright);

  1512. 

  1513.         checkStringPtr(info.filename);

  1514.         checkStringPtr(info.name);

  1515.         checkStringPtr(info.iconName);

  1516. 

  1517.         return &info;

  1518.     }

  1519. 

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

  1521.     return &info;

  1522. }

  1523. 

  1524. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1525. {

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

  1527. 

  1528.     static CarlaPortCountInfo info;

  1529. 

  1530.     // reset

  1531.     info.ins   = 0;

  1532.     info.outs  = 0;

  1533. 

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

  1535. 

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

  1537.     {

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

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

  1540.         return &info;

  1541.     }

  1542. 

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

  1544.     return &info;

  1545. }

  1546. 

  1547. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1548. {

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

  1550. 

  1551.     static CarlaPortCountInfo info;

  1552. 

  1553.     // reset

  1554.     info.ins   = 0;

  1555.     info.outs  = 0;

  1556. 

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

  1558. 

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

  1560.     {

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

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

  1563.         return &info;

  1564.     }

  1565. 

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

  1567.     return &info;

  1568. }

  1569. 

  1570. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1571. {

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

  1573. 

  1574.     static CarlaPortCountInfo info;

  1575. 

  1576.     // reset

  1577.     info.ins   = 0;

  1578.     info.outs  = 0;

  1579. 

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

  1581. 

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

  1583.     {

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

  1585.         return &info;

  1586.     }

  1587. 

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

  1589.     return &info;

  1590. }

  1591. 

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

  1593. {

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

  1595. 

  1596.     static CarlaParameterInfo info;

  1597. 

  1598.     // reset

  1599.     info.scalePointCount = 0;

  1600. 

  1601.     // cleanup

  1602.     if (info.name != gNullCharPtr)

  1603.     {

  1604.         delete[] info.name;

  1605.         info.name = gNullCharPtr;

  1606.     }

  1607. 

  1608.     if (info.symbol != gNullCharPtr)

  1609.     {

  1610.         delete[] info.symbol;

  1611.         info.symbol = gNullCharPtr;

  1612.     }

  1613. 

  1614.     if (info.unit != gNullCharPtr)

  1615.     {

  1616.         delete[] info.unit;

  1617.         info.unit = gNullCharPtr;

  1618.     }

  1619. 

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

  1621. 

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

  1623.     {

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

  1625.         {

  1626.             char strBufName[STR_MAX+1];

  1627.             char strBufSymbol[STR_MAX+1];

  1628.             char strBufUnit[STR_MAX+1];

  1629. 

  1630.             carla_zeroChar(strBufName, STR_MAX+1);

  1631.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1632.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1633. 

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

  1635. 

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

  1637.             info.name = carla_strdup(strBufName);

  1638. 

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

  1640.             info.symbol = carla_strdup(strBufSymbol);

  1641. 

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

  1643.             info.unit = carla_strdup(strBufUnit);

  1644.         }

  1645.         else

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

  1647. 

  1648.         return &info;

  1649.     }

  1650. 

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

  1652.     return &info;

  1653. }

  1654. 

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

  1656. {

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

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

  1659. 

  1660.     static CarlaScalePointInfo info;

  1661. 

  1662.     // reset

  1663.     info.value = 0.0f;

  1664. 

  1665.     // cleanup

  1666.     if (info.label != gNullCharPtr)

  1667.     {

  1668.         delete[] info.label;

  1669.         info.label = gNullCharPtr;

  1670.     }

  1671. 

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

  1673. 

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

  1675.     {

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

  1677.         {

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

  1679.             {

  1680.                 char strBufLabel[STR_MAX+1];

  1681.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1682. 

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

  1684. 

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

  1686.                 info.label = carla_strdup(strBufLabel);

  1687.             }

  1688.             else

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

  1690.         }

  1691.         else

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

  1693. 

  1694.         return &info;

  1695.     }

  1696. 

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

  1698.     return &info;

  1699. }

  1700. 

  1701. // -------------------------------------------------------------------------------------------------------------------

  1702. 

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

  1704. {

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

  1706. 

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

  1708. 

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

  1710. 

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

  1712.     {

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

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

  1715. 

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

  1717.         return &fallbackParameterData;

  1718.     }

  1719. 

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

  1721.     return &fallbackParameterData;

  1722. }

  1723. 

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

  1725. {

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

  1727. 

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

  1729. 

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

  1731. 

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

  1733.     {

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

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

  1736. 

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

  1738.         return &fallbackParamRanges;

  1739.     }

  1740. 

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

  1742.     return &fallbackParamRanges;

  1743. }

  1744. 

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

  1746. {

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

  1748. 

  1749.     static MidiProgramData midiProgData;

  1750. 

  1751.     // reset

  1752.     midiProgData.bank    = 0;

  1753.     midiProgData.program = 0;

  1754.     midiProgData.name    = gNullCharPtr;

  1755. 

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

  1757. 

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

  1759.     {

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

  1761.         {

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

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

  1764.             checkStringPtr(midiProgData.name);

  1765.             return &midiProgData;

  1766.         }

  1767. 

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

  1769.         return &midiProgData;

  1770.     }

  1771. 

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

  1773.     return &midiProgData;

  1774. }

  1775. 

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

  1777. {

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

  1779. 

  1780.     static CustomData customData;

  1781. 

  1782.     // reset

  1783.     customData.type  = gNullCharPtr;

  1784.     customData.key   = gNullCharPtr;

  1785.     customData.value = gNullCharPtr;

  1786. 

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

  1788. 

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

  1790.     {

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

  1792.         {

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

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

  1795.             checkStringPtr(customData.type);

  1796.             checkStringPtr(customData.key);

  1797.             checkStringPtr(customData.value);

  1798.             return &customData;

  1799.         }

  1800. 

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

  1802.         return &customData;

  1803.     }

  1804. 

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

  1806.     return &customData;

  1807. }

  1808. 

  1809. const char* carla_get_chunk_data(uint pluginId)

  1810. {

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

  1812. 

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

  1814. 

  1815.     static CarlaString chunkData;

  1816. 

  1817.     // cleanup

  1818.     chunkData.clear();

  1819. 

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

  1821.     {

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

  1823.         {

  1824.             void* data = nullptr;

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

  1826. 

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

  1828.             {

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

  1830. 

  1831.                 return chunkData;

  1832.             }

  1833.             else

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

  1835.         }

  1836.         else

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

  1838. 

  1839.         return nullptr;

  1840.     }

  1841. 

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

  1843.     return nullptr;

  1844. }

  1845. 

  1846. // -------------------------------------------------------------------------------------------------------------------

  1847. 

  1848. uint32_t carla_get_parameter_count(uint pluginId)

  1849. {

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

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

  1852. 

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

  1854.         return plugin->getParameterCount();

  1855. 

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

  1857.     return 0;

  1858. }

  1859. 

  1860. uint32_t carla_get_program_count(uint pluginId)

  1861. {

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

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

  1864. 

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

  1866.         return plugin->getProgramCount();

  1867. 

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

  1869.     return 0;

  1870. }

  1871. 

  1872. uint32_t carla_get_midi_program_count(uint pluginId)

  1873. {

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

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

  1876. 

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

  1878.         return plugin->getMidiProgramCount();

  1879. 

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

  1881.     return 0;

  1882. }

  1883. 

  1884. uint32_t carla_get_custom_data_count(uint pluginId)

  1885. {

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

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

  1888. 

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

  1890.         return plugin->getCustomDataCount();

  1891. 

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

  1893.     return 0;

  1894. }

  1895. 

  1896. // -------------------------------------------------------------------------------------------------------------------

  1897. 

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

  1899. {

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

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

  1902. 

  1903.     static char textBuf[STR_MAX+1];

  1904. 

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

  1906.     {

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

  1908.         {

  1909.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1911.             return textBuf;

  1912.         }

  1913. 

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

  1915.         return nullptr;

  1916.     }

  1917. 

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

  1919.     return nullptr;

  1920. }

  1921. 

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

  1923. {

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

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

  1926. 

  1927.     static char programName[STR_MAX+1];

  1928. 

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

  1930.     {

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

  1932.         {

  1933.             carla_zeroChar(programName, STR_MAX+1);

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

  1935.             return programName;

  1936.         }

  1937. 

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

  1939.         return nullptr;

  1940.     }

  1941. 

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

  1943.     return nullptr;

  1944. }

  1945. 

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

  1947. {

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

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

  1950. 

  1951.     static char midiProgramName[STR_MAX+1];

  1952. 

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

  1954.     {

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

  1956.         {

  1957.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1959.             return midiProgramName;

  1960.         }

  1961. 

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

  1963.         return nullptr;

  1964.     }

  1965. 

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

  1967.     return nullptr;

  1968. }

  1969. 

  1970. const char* carla_get_real_plugin_name(uint pluginId)

  1971. {

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

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

  1974. 

  1975.     static char realPluginName[STR_MAX+1];

  1976. 

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

  1978.     {

  1979.         carla_zeroChar(realPluginName, STR_MAX+1);

  1980.         plugin->getRealName(realPluginName);

  1981.         return realPluginName;

  1982.     }

  1983. 

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

  1985.     return nullptr;

  1986. }

  1987. 

  1988. // -------------------------------------------------------------------------------------------------------------------

  1989. 

  1990. int32_t carla_get_current_program_index(uint pluginId)

  1991. {

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

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

  1994. 

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

  1996.         return plugin->getCurrentProgram();

  1997. 

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

  1999.     return -1;

  2000. }

  2001. 

  2002. int32_t carla_get_current_midi_program_index(uint pluginId)

  2003. {

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

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

  2006. 

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

  2008.         return plugin->getCurrentMidiProgram();

  2009. 

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

  2011.     return -1;

  2012. }

  2013. 

  2014. // -------------------------------------------------------------------------------------------------------------------

  2015. 

  2016. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  2017. {

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

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

  2020. 

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

  2022.     {

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

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

  2025. 

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

  2027.         return 0.0f;

  2028.     }

  2029. 

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

  2031.     return 0.0f;

  2032. }

  2033. 

  2034. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  2035. {

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

  2037. 

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

  2039.     {

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

  2041.             return plugin->getParameterValue(parameterId);

  2042. 

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

  2044.         return 0.0f;

  2045.     }

  2046. 

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

  2048.     return 0.0f;

  2049. }

  2050. 

  2051. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  2052. {

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

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

  2055. 

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

  2057.         return plugin->getInternalParameterValue(parameterId);

  2058. 

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

  2060.     return 0.0f;

  2061. }

  2062. 

  2063. // -------------------------------------------------------------------------------------------------------------------

  2064. 

  2065. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  2066. {

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

  2068. 

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

  2070. }

  2071. 

  2072. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  2073. {

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

  2075. 

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

  2077. }

  2078. 

  2079. // -------------------------------------------------------------------------------------------------------------------

  2080. 

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

  2082. {

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

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

  2085. 

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

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

  2088. 

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

  2090. }

  2091. 

  2092. void carla_set_active(uint pluginId, bool onOff)

  2093. {

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

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

  2096. 

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

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

  2099. 

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

  2101. }

  2102. 

  2103. #ifndef BUILD_BRIDGE

  2104. void carla_set_drywet(uint pluginId, float value)

  2105. {

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

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

  2108. 

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

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

  2111. 

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

  2113. }

  2114. 

  2115. void carla_set_volume(uint pluginId, float value)

  2116. {

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

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

  2119. 

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

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

  2122. 

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

  2124. }

  2125. 

  2126. void carla_set_balance_left(uint pluginId, float value)

  2127. {

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

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

  2130. 

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

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

  2133. 

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

  2135. }

  2136. 

  2137. void carla_set_balance_right(uint pluginId, float value)

  2138. {

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

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

  2141. 

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

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

  2144. 

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

  2146. }

  2147. 

  2148. void carla_set_panning(uint pluginId, float value)

  2149. {

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

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

  2152. 

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

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

  2155. 

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

  2157. }

  2158. #endif

  2159. 

  2160. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  2161. {

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

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

  2164. 

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

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

  2167. 

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

  2169. }

  2170. 

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

  2172. 

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

  2174. {

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

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

  2177. 

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

  2179.     {

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

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

  2182. 

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

  2184.         return;

  2185.     }

  2186. 

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

  2188. }

  2189. 

  2190. #ifndef BUILD_BRIDGE

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

  2192. {

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

  2194.     CARLA_SAFE_ASSERT_RETURN(channel >= MAX_MIDI_CHANNELS,);

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

  2196. 

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

  2198.     {

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

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

  2201. 

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

  2203.         return;

  2204.     }

  2205. 

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

  2207. }

  2208. 

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

  2210. {

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

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

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

  2214. 

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

  2216.     {

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

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

  2219. 

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

  2221.         return;

  2222.     }

  2223. 

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

  2225. }

  2226. #endif

  2227. 

  2228. // -------------------------------------------------------------------------------------------------------------------

  2229. 

  2230. void carla_set_program(uint pluginId, uint32_t programId)

  2231. {

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

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

  2234. 

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

  2236.     {

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

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

  2239. 

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

  2241.         return;

  2242.     }

  2243. 

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

  2245. }

  2246. 

  2247. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2248. {

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

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

  2251. 

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

  2253.     {

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

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

  2256. 

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

  2258.         return;

  2259.     }

  2260. 

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

  2262. }

  2263. 

  2264. // -------------------------------------------------------------------------------------------------------------------

  2265. 

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

  2267. {

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

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

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

  2271.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2273. 

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

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

  2276. 

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

  2278. }

  2279. 

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

  2281. {

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

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

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

  2285. 

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

  2287.     {

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

  2289.             return plugin->setChunkData(chunkData);

  2290. 

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

  2292.         return;

  2293.     }

  2294. 

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

  2296. }

  2297. 

  2298. // -------------------------------------------------------------------------------------------------------------------

  2299. 

  2300. void carla_prepare_for_save(uint pluginId)

  2301. {

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

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

  2304. 

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

  2306.         return plugin->prepareForSave();

  2307. 

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

  2309. }

  2310. 

  2311. void carla_reset_parameters(uint pluginId)

  2312. {

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

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

  2315. 

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

  2317.         return plugin->resetParameters();

  2318. 

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

  2320. }

  2321. 

  2322. void carla_randomize_parameters(uint pluginId)

  2323. {

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

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

  2326. 

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

  2328.         return plugin->randomizeParameters();

  2329. 

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

  2331. }

  2332. 

  2333. #ifndef BUILD_BRIDGE

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

  2335. {

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

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

  2338. 

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

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

  2341. 

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

  2343. }

  2344. #endif

  2345. 

  2346. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2347. {

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

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

  2350. 

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

  2352.         return plugin->showCustomUI(yesNo);

  2353. 

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

  2355. }

  2356. 

  2357. // -------------------------------------------------------------------------------------------------------------------

  2358. 

  2359. uint32_t carla_get_buffer_size()

  2360. {

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

  2362.     carla_debug("carla_get_buffer_size()");

  2363. 

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

  2365. }

  2366. 

  2367. double carla_get_sample_rate()

  2368. {

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

  2370.     carla_debug("carla_get_sample_rate()");

  2371. 

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

  2373. }

  2374. 

  2375. // -------------------------------------------------------------------------------------------------------------------

  2376. 

  2377. const char* carla_get_last_error()

  2378. {

  2379.     carla_debug("carla_get_last_error()");

  2380. 

  2381.     if (gStandalone.engine != nullptr)

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

  2383. 

  2384.     return gStandalone.lastError;

  2385. }

  2386. 

  2387. const char* carla_get_host_osc_url_tcp()

  2388. {

  2389.     carla_debug("carla_get_host_osc_url_tcp()");

  2390. 

  2391.     if (gStandalone.engine == nullptr)

  2392.     {

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

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

  2395.         return nullptr;

  2396.     }

  2397. 

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

  2399. }

  2400. 

  2401. const char* carla_get_host_osc_url_udp()

  2402. {

  2403.     carla_debug("carla_get_host_osc_url_udp()");

  2404. 

  2405.     if (gStandalone.engine == nullptr)

  2406.     {

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

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

  2409.         return nullptr;

  2410.     }

  2411. 

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

  2413. }

  2414. 

  2415. // -------------------------------------------------------------------------------------------------------------------

  2416. 

  2417. #ifdef WANT_DSSI

  2418. # include "CarlaDssiUtils.cpp"

  2419. #endif

  2420. 

  2421. #include "CarlaStateUtils.cpp"

  2422. 

  2423. #if 0

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

  2425. {

  2426.     return 0;

  2427. }

  2428. #endif

  2429. 

  2430. // -------------------------------------------------------------------------------------------------------------------