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.
2006 Commits
16 Branches
265MB
Tree: 4c44998a25
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4c44998a25'
${ noResults }
Carla/source/backend/CarlaStandalone.cpp

2418 lines
79KB
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 "juce_audio_formats.h"

  33. 

  34. #ifdef BUILD_BRIDGE

  35. # undef HAVE_JUCE_UI

  36. #endif

  37. 

  38. #ifdef HAVE_JUCE_UI

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

  50. using juce::AudioFormatManager;

  51. using juce::String;

  52. using juce::StringArray;

  53. 

  54. // -------------------------------------------------------------------------------------------------------------------

  55. // Juce Message Thread

  56. 

  57. #if defined(HAVE_JUCE_UI) && defined(CARLA_OS_LINUX)

  58. 

  59. class JuceMessageThread : public Thread

  60. {

  61. public:

  62.     JuceMessageThread()

  63.       : Thread("JuceMessageThread"),

  64.         fInitialised(false)

  65.     {

  66.     }

  67. 

  68.     ~JuceMessageThread() override

  69.     {

  70.         stop();

  71.     }

  72. 

  73.     void start()

  74.     {

  75.         CARLA_SAFE_ASSERT_RETURN(! fInitialised,);

  76. 

  77.         fInitialised = false;

  78. 

  79.         startThread(7);

  80. 

  81.         while (! fInitialised)

  82.             sleep(1);

  83.     }

  84. 

  85.     void stop()

  86.     {

  87.         signalThreadShouldExit();

  88.         waitForThreadToExit(5000);

  89.     }

  90. 

  91. protected:

  92.     void run() override

  93.     {

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

  95.         CARLA_SAFE_ASSERT_RETURN(msgMgr != nullptr,);

  96. 

  97.         msgMgr->setCurrentThreadAsMessageThread();

  98.         fInitialised = true;

  99. 

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

  101.         {}

  102. 

  103.         fInitialised = false;

  104.     }

  105. 

  106. private:

  107.     volatile bool fInitialised;

  108. 

  109.     CARLA_DECLARE_NON_COPY_CLASS(JuceMessageThread)

  110. };

  111. 

  112. #endif // defined(HAVE_JUCE_UI) && defined(CARLA_OS_LINUX)

  113. 

  114. // -------------------------------------------------------------------------------------------------------------------

  115. // Single, standalone engine

  116. 

  117. struct CarlaBackendStandalone {

  118.     CarlaEngine*       engine;

  119.     EngineCallbackFunc engineCallback;

  120.     void*              engineCallbackPtr;

  121.     EngineOptions      engineOptions;

  122. 

  123.     FileCallbackFunc fileCallback;

  124.     void*            fileCallbackPtr;

  125. 

  126.     CarlaString lastError;

  127. 

  128. #if defined(HAVE_JUCE_UI) && defined(CARLA_OS_LINUX)

  129.     JuceMessageThread juceMsgThread;

  130. #endif

  131. 

  132.     CarlaBackendStandalone()

  133.         : engine(nullptr),

  134.           engineCallback(nullptr),

  135.           engineCallbackPtr(nullptr),

  136.           fileCallback(nullptr),

  137.           fileCallbackPtr(nullptr)

  138.     {

  139. #ifdef BUILD_BRIDGE

  140.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  141.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  142.         engineOptions.forceStereo         = false;

  143.         engineOptions.preferPluginBridges = false;

  144.         engineOptions.preferUiBridges     = false;

  145. #else

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

  147.             return;

  148. 

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

  150. #endif

  151.     }

  152. 

  153.     ~CarlaBackendStandalone()

  154.     {

  155.         CARLA_SAFE_ASSERT(engine == nullptr);

  156. #ifdef HAVE_JUCE_UI

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

  158. #endif

  159.     }

  160. 

  161. #ifdef HAVE_JUCE_UI

  162.     void init()

  163.     {

  164.         JUCE_AUTORELEASEPOOL

  165.         {

  166.             initialiseJuce_GUI();

  167. # ifdef CARLA_OS_LINUX

  168.             juceMsgThread.start();

  169. # else

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

  171.                 msgMgr->setCurrentThreadAsMessageThread();

  172. # endif

  173.         }

  174.     }

  175. 

  176.     void close()

  177.     {

  178.         JUCE_AUTORELEASEPOOL

  179.         {

  180. # ifdef CARLA_OS_LINUX

  181.             juceMsgThread.stop();

  182. # else

  183.             MessageManager::deleteInstance();

  184. # endif

  185.             shutdownJuce_GUI();

  186.         }

  187.     }

  188. 

  189. # ifndef CARLA_OS_LINUX

  190.     void idle()

  191.     {

  192.         JUCE_AUTORELEASEPOOL

  193.         {

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

  195.                 msgMgr->runDispatchLoopUntil(5);

  196.         }

  197.     }

  198. # endif

  199. #endif

  200. 

  201.     CARLA_PREVENT_HEAP_ALLOCATION

  202.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  203. };

  204. 

  205. static CarlaBackendStandalone gStandalone;

  206. 

  207. // -------------------------------------------------------------------------------------------------------------------

  208. // NSM support

  209. 

  210. #define NSM_API_VERSION_MAJOR 1

  211. #define NSM_API_VERSION_MINOR 2

  212. 

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

  214. #define NSM_CLIENT_FEATURES ":switch:"

  215. 

  216. class CarlaNSM

  217. {

  218. public:

  219.     CarlaNSM() noexcept

  220.         : fOscServer(nullptr),

  221.           fHasBroadcast(false),

  222.           fHasShowHideUI(false) {}

  223. 

  224.     ~CarlaNSM()

  225.     {

  226.         if (fOscServer != nullptr)

  227.         {

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

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

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

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

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

  233.             lo_server_free(fOscServer);

  234.             fOscServer = nullptr;

  235.         }

  236.     }

  237. 

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

  239.     {

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

  241. 

  242.         if (NSM_URL == nullptr)

  243.             return;

  244. 

  245.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  246. 

  247.         if (addr == nullptr)

  248.             return;

  249. 

  250.         const int proto = lo_address_get_protocol(addr);

  251. 

  252.         if (fOscServer == nullptr)

  253.         {

  254.             // create new OSC server

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

  256. 

  257.             // register message handlers and start OSC thread

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

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

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

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

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

  263.             // /nsm/client/session_is_loaded

  264.         }

  265. 

  266. #ifndef BUILD_ANSI_TEST

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

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

  269. #endif

  270. 

  271.         lo_address_free(addr);

  272.     }

  273. 

  274.     void idle() noexcept

  275.     {

  276.         if (fOscServer == nullptr)

  277.             return;

  278. 

  279.         for (;;)

  280.         {

  281.             try {

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

  283.                     break;

  284.             }

  285.             CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  286.         }

  287.     }

  288. 

  289. protected:

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

  291.     {

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

  293. 

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

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

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

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

  298. 

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

  300. 

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

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

  303. 

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

  305. 

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

  307. 

  308.         return 0;

  309. 

  310. #ifndef DEBUG

  311.         // unused

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

  313. #endif

  314.     }

  315. 

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

  317.     {

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

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

  320. 

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

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

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

  324. 

  325.         if (! carla_is_engine_running())

  326.         {

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

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

  329. 

  330.             carla_engine_init("JACK", clientId);

  331.         }

  332.         else

  333.         {

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

  335. 

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

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

  338.         }

  339. 

  340.         fClientId = clientId;

  341. 

  342.         fProjectPath  = projectPath;

  343.         fProjectPath += ".carxp";

  344. 

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

  346. 

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

  348. 

  349. #ifndef BUILD_ANSI_TEST

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

  351. #endif

  352. 

  353. #if 0

  354.         if (fHasBroadcast)

  355.         {

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

  357. 

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

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

  360. 

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

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

  363. 

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

  365. 

  366.             std::free(url);

  367. 

  368.             carla_stdout("Broadcast sent!");

  369.         }

  370.         else

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

  372. #endif

  373. 

  374.         return 0;

  375. 

  376. #ifndef DEBUG

  377.         // unused

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

  379. #endif

  380.     }

  381. 

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

  383.     {

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

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

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

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

  388. 

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

  390. 

  391. #ifndef BUILD_ANSI_TEST

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

  393. #endif

  394. 

  395.         return 0;

  396. 

  397. #ifndef DEBUG

  398.         // unused

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

  400. #endif

  401.     }

  402. 

  403. #if 0

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

  405.     {

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

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

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

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

  410. 

  411. #ifndef BUILD_ANSI_TEST

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

  413. #endif

  414. 

  415.         return 0;

  416.     }

  417. #endif

  418. 

  419. private:

  420.     lo_server fOscServer;

  421. 

  422.     CarlaString fClientId;

  423.     CarlaString fProjectPath;

  424. 

  425.     bool fHasBroadcast;

  426.     bool fHasShowHideUI;

  427. 

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

  429. 

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

  431.     {

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

  433.     }

  434. 

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

  436.     {

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

  438.     }

  439. 

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

  441.     {

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

  443.     }

  444. 

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

  446.     {

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

  448.     }

  449. 

  450. #if 0

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

  452.     {

  453.         return handlePtr->handleShowHideGui(true);

  454.     }

  455. 

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

  457.     {

  458.         return handlePtr->handleShowHideGui(false);

  459.     }

  460. #endif

  461. 

  462.     #undef handlePtr

  463. 

  464.     CARLA_PREVENT_HEAP_ALLOCATION

  465.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  466. };

  467. 

  468. static CarlaNSM gNSM;

  469. 

  470. // -------------------------------------------------------------------------------------------------------------------

  471. // Always return a valid string ptr

  472. 

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

  474. 

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

  476. {

  477.     if (charPtr == nullptr)

  478.         charPtr = gNullCharPtr;

  479. }

  480. 

  481. // -------------------------------------------------------------------------------------------------------------------

  482. // Constructors

  483. 

  484. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  485.     : type(CB::PLUGIN_NONE),

  486.       category(CB::PLUGIN_CATEGORY_NONE),

  487.       hints(0x0),

  488.       optionsAvailable(0x0),

  489.       optionsEnabled(0x0),

  490.       filename(gNullCharPtr),

  491.       name(gNullCharPtr),

  492.       label(gNullCharPtr),

  493.       maker(gNullCharPtr),

  494.       copyright(gNullCharPtr),

  495.       iconName(gNullCharPtr),

  496.       uniqueId(0) {}

  497. 

  498. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  499. {

  500.     if (label != gNullCharPtr)

  501.         delete[] label;

  502.     if (maker != gNullCharPtr)

  503.         delete[] maker;

  504.     if (copyright != gNullCharPtr)

  505.         delete[] copyright;

  506. }

  507. 

  508. _CarlaNativePluginInfo::_CarlaNativePluginInfo() noexcept

  509.     : category(CB::PLUGIN_CATEGORY_NONE),

  510.       hints(0x0),

  511.       audioIns(0),

  512.       audioOuts(0),

  513.       midiIns(0),

  514.       midiOuts(0),

  515.       parameterIns(0),

  516.       parameterOuts(0),

  517.       name(gNullCharPtr),

  518.       label(gNullCharPtr),

  519.       maker(gNullCharPtr),

  520.       copyright(gNullCharPtr) {}

  521. 

  522. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  523.     : name(gNullCharPtr),

  524.       symbol(gNullCharPtr),

  525.       unit(gNullCharPtr),

  526.       scalePointCount(0) {}

  527. 

  528. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  529. {

  530.     if (name != gNullCharPtr)

  531.         delete[] name;

  532.     if (symbol != gNullCharPtr)

  533.         delete[] symbol;

  534.     if (unit != gNullCharPtr)

  535.         delete[] unit;

  536. }

  537. 

  538. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  539.     : value(0.0f),

  540.       label(gNullCharPtr) {}

  541. 

  542. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  543. {

  544.     if (label != gNullCharPtr)

  545.         delete[] label;

  546. }

  547. 

  548. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  549.     : playing(false),

  550.       frame(0),

  551.       bar(0),

  552.       beat(0),

  553.       tick(0),

  554.       bpm(0.0) {}

  555. 

  556. // -------------------------------------------------------------------------------------------------------------------

  557. // API

  558. 

  559. const char* carla_get_complete_license_text()

  560. {

  561.     carla_debug("carla_get_complete_license_text()");

  562. 

  563.     static CarlaString retText;

  564. 

  565.     if (retText.isEmpty())

  566.     {

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

  568. 

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

  570.         text1 += "<ul>";

  571. 

  572.         // Plugin formats

  573. #ifdef WANT_LADSPA

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

  575. #endif

  576. #ifdef WANT_DSSI

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

  578. #endif

  579. #ifdef WANT_LV2

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

  581. #endif

  582. #ifdef WANT_VST

  583. # ifdef VESTIGE_HEADER

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

  585. # else

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

  587. # endif

  588. #endif

  589. #ifdef WANT_AU

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

  591. #endif

  592. 

  593.         // Sample kit libraries

  594. #ifdef WANT_FLUIDSYNTH

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

  596. #endif

  597. #ifdef WANT_LINUXSAMPLER

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

  599. #endif

  600. 

  601. #ifdef WANT_NATIVE

  602.         // Internal plugins

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

  604. # ifdef WANT_ZYNADDSUBFX

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

  606. #  ifdef WANT_ZYNADDSUBFX_UI

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

  608. #  endif

  609. # endif

  610. #endif

  611. 

  612.         // misc libs

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

  614. #ifdef WANT_LV2

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

  616. #endif

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

  618. 

  619.         // end

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

  621. 

  622.         // code snippets

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

  624.         text5 += "<ul>";

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

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

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

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

  629. 

  630. #ifdef WANT_LINUXSAMPLER

  631.         // LinuxSampler GPL exception

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

  633. #endif

  634. 

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

  636.     }

  637. 

  638.     return retText;

  639. }

  640. 

  641. const char* carla_get_supported_file_extensions()

  642. {

  643.     carla_debug("carla_get_supported_file_extensions()");

  644. 

  645.     static CarlaString retText;

  646. 

  647.     if (retText.isEmpty())

  648.     {

  649.         // Base types

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

  651. 

  652.         // Sample kits

  653. #ifdef WANT_FLUIDSYNTH

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

  655. #endif

  656. #ifdef WANT_LINUXSAMPLER

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

  658. #endif

  659. 

  660.         // Audio files

  661.         AudioFormatManager afm;

  662.         afm.registerBasicFormats();

  663. 

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

  665.         {

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

  667. 

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

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

  670.         }

  671. 

  672.         // MIDI files

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

  674. 

  675.         // Plugin presets

  676. #ifdef WANT_ZYNADDSUBFX

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

  678. #endif

  679.     }

  680. 

  681.     return retText;

  682. }

  683. 

  684. // -------------------------------------------------------------------------------------------------------------------

  685. 

  686. unsigned int carla_get_engine_driver_count()

  687. {

  688.     carla_debug("carla_get_engine_driver_count()");

  689. 

  690.     return CarlaEngine::getDriverCount();

  691. }

  692. 

  693. const char* carla_get_engine_driver_name(unsigned int index)

  694. {

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

  696. 

  697.     return CarlaEngine::getDriverName(index);

  698. }

  699. 

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

  701. {

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

  703. 

  704.     return CarlaEngine::getDriverDeviceNames(index);

  705. }

  706. 

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

  708. {

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

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

  711. 

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

  713.     {

  714.         static EngineDriverDeviceInfo devInfo;

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

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

  717. 

  718.         devInfo.hints       = ret->hints;

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

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

  721.         return &devInfo;

  722.     }

  723. 

  724.     return nullptr;

  725. }

  726. 

  727. // -------------------------------------------------------------------------------------------------------------------

  728. 

  729. unsigned int carla_get_internal_plugin_count()

  730. {

  731.     carla_debug("carla_get_internal_plugin_count()");

  732. 

  733. #ifdef WANT_NATIVE

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

  735. #else

  736.     return 0;

  737. #endif

  738. }

  739. 

  740. const CarlaNativePluginInfo* carla_get_internal_plugin_info(unsigned int index)

  741. {

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

  743. 

  744. #ifdef WANT_NATIVE

  745.     static CarlaNativePluginInfo info;

  746. 

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

  748. 

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

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

  751. 

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

  753.      info.hints    = 0x0;

  754. 

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

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

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

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

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

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

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

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

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

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

  765. 

  766.      info.audioIns  = nativePlugin->audioIns;

  767.      info.audioOuts = nativePlugin->audioOuts;

  768.      info.midiIns   = nativePlugin->midiIns;

  769.      info.midiOuts  = nativePlugin->midiOuts;

  770.      info.parameterIns  = nativePlugin->paramIns;

  771.      info.parameterOuts = nativePlugin->paramOuts;

  772. 

  773.      info.name      = nativePlugin->name;

  774.      info.label     = nativePlugin->label;

  775.      info.maker     = nativePlugin->maker;

  776.      info.copyright = nativePlugin->copyright;

  777. 

  778.      checkStringPtr(info.name);

  779.      checkStringPtr(info.label);

  780.      checkStringPtr(info.maker);

  781.      checkStringPtr(info.copyright);

  782. 

  783.     return &info;

  784. #else

  785.     return nullptr;

  786. 

  787.     // unused

  788.     (void)index;

  789. #endif

  790. }

  791. 

  792. // -------------------------------------------------------------------------------------------------------------------

  793. 

  794. const CarlaEngine* carla_get_engine()

  795. {

  796.     carla_debug("carla_get_engine()");

  797. 

  798.     return gStandalone.engine;

  799. }

  800. 

  801. // -------------------------------------------------------------------------------------------------------------------

  802. 

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

  804. {

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

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

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

  808. 

  809.     if (gStandalone.engine != nullptr)

  810.     {

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

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

  813.         return false;

  814.     }

  815. 

  816. #ifdef CARLA_OS_WIN

  817.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  818. #endif

  819. 

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

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

  822.     {

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

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

  825.     }

  826. 

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

  828. 

  829.     if (gStandalone.engine == nullptr)

  830.     {

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

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

  833.         return false;

  834.     }

  835. 

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

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

  838. 

  839. #ifdef BUILD_BRIDGE

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

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

  842. #else

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

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

  845. #endif

  846. 

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

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

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

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

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

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

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

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

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

  856. 

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

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

  859. 

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

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

  862. 

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

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

  865. 

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

  867.     {

  868.         char strBuf[STR_MAX+1];

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

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

  871.     }

  872.     else

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

  874. 

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

  876.     {

  877.         gStandalone.lastError = "No error";

  878. #ifdef HAVE_JUCE_UI

  879.         gStandalone.init();

  880. #endif

  881.         return true;

  882.     }

  883.     else

  884.     {

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

  886.         delete gStandalone.engine;

  887.         gStandalone.engine = nullptr;

  888.         return false;

  889.     }

  890. }

  891. 

  892. #ifdef BUILD_BRIDGE

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

  894. {

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

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

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

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

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

  900. 

  901.     if (gStandalone.engine != nullptr)

  902.     {

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

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

  905.         return false;

  906.     }

  907. 

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

  909. 

  910.     if (gStandalone.engine == nullptr)

  911.     {

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

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

  914.         return false;

  915.     }

  916. 

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

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

  919. 

  920.     // forced options for bridge mode

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

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

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

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

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

  926. 

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

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

  929. 

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

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

  932. 

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

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

  935. 

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

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

  938. 

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

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

  941. 

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

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

  944. 

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

  946.     {

  947.         gStandalone.lastError = "No error";

  948. #ifdef HAVE_JUCE_UI

  949.         gStandalone.init();

  950. #endif

  951.         return true;

  952.     }

  953.     else

  954.     {

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

  956.         delete gStandalone.engine;

  957.         gStandalone.engine = nullptr;

  958.         return false;

  959.     }

  960. }

  961. #endif

  962. 

  963. bool carla_engine_close()

  964. {

  965.     carla_debug("carla_engine_close()");

  966. 

  967.     if (gStandalone.engine == nullptr)

  968.     {

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

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

  971.         return false;

  972.     }

  973. 

  974.     gStandalone.engine->setAboutToClose();

  975.     gStandalone.engine->removeAllPlugins();

  976. 

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

  978. 

  979.     if (! closed)

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

  981. 

  982. #ifdef HAVE_JUCE_UI

  983.     gStandalone.close();

  984. #endif

  985. 

  986.     delete gStandalone.engine;

  987.     gStandalone.engine = nullptr;

  988. 

  989.     return closed;

  990. }

  991. 

  992. void carla_engine_idle()

  993. {

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

  995. 

  996.     gNSM.idle();

  997. #if defined(HAVE_JUCE_UI) && ! defined(CARLA_OS_LINUX)

  998.     gStandalone.idle();

  999. #endif

  1000.     gStandalone.engine->idle();

  1001. }

  1002. 

  1003. bool carla_is_engine_running()

  1004. {

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

  1006. }

  1007. 

  1008. void carla_set_engine_about_to_close()

  1009. {

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

  1011.     carla_debug("carla_set_engine_about_to_close()");

  1012. 

  1013.     gStandalone.engine->setAboutToClose();

  1014. }

  1015. 

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

  1017. {

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

  1019. 

  1020.     gStandalone.engineCallback    = func;

  1021.     gStandalone.engineCallbackPtr = ptr;

  1022. 

  1023.     if (gStandalone.engine != nullptr)

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

  1025. 

  1026. //#ifdef WANT_LOGS

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

  1028. //#endif

  1029. }

  1030. 

  1031. #ifndef BUILD_BRIDGE

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

  1033. {

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

  1035. 

  1036.     switch (option)

  1037.     {

  1038.     case CB::ENGINE_OPTION_DEBUG:

  1039.         break;

  1040. 

  1041.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  1044.         break;

  1045. 

  1046.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1049.         break;

  1050. 

  1051.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  1054.         break;

  1055. 

  1056.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1059.         break;

  1060. 

  1061.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1064.         break;

  1065. 

  1066.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1069.         break;

  1070. 

  1071.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  1072.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1074.         break;

  1075. 

  1076.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1077.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1079.         break;

  1080. 

  1081.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1084.         break;

  1085. 

  1086.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1087.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1089.         break;

  1090. 

  1091.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1092.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1094.         break;

  1095. 

  1096.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  1097.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1098. 

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

  1100.             delete[] gStandalone.engineOptions.audioDevice;

  1101. 

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

  1103.         break;

  1104. 

  1105.     case CB:: ENGINE_OPTION_NSM_INIT:

  1106.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  1108.         gNSM.announce(value, valueStr);

  1109.         break;

  1110. 

  1111.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  1113. 

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

  1115.             delete[] gStandalone.engineOptions.binaryDir;

  1116. 

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

  1118.         break;

  1119. 

  1120.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  1122. 

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

  1124.             delete[] gStandalone.engineOptions.resourceDir;

  1125. 

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

  1127.         break;

  1128. 

  1129.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

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

  1132.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1134.         break;

  1135.     }

  1136. 

  1137.     if (gStandalone.engine != nullptr)

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

  1139. }

  1140. #endif

  1141. 

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

  1143. {

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

  1145. 

  1146.     gStandalone.fileCallback    = func;

  1147.     gStandalone.fileCallbackPtr = ptr;

  1148. 

  1149.     if (gStandalone.engine != nullptr)

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

  1151. }

  1152. 

  1153. // -------------------------------------------------------------------------------------------------------------------

  1154. 

  1155. bool carla_load_file(const char* filename)

  1156. {

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

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

  1159. 

  1160.     if (gStandalone.engine != nullptr)

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

  1162. 

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

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

  1165.     return false;

  1166. }

  1167. 

  1168. bool carla_load_project(const char* filename)

  1169. {

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

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

  1172. 

  1173.     if (gStandalone.engine != nullptr)

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

  1175. 

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

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

  1178.     return false;

  1179. }

  1180. 

  1181. bool carla_save_project(const char* filename)

  1182. {

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

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

  1185. 

  1186.     if (gStandalone.engine != nullptr)

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

  1188. 

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

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

  1191.     return false;

  1192. }

  1193. 

  1194. #ifndef BUILD_BRIDGE

  1195. // -------------------------------------------------------------------------------------------------------------------

  1196. 

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

  1198. {

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

  1200. 

  1201.     if (gStandalone.engine != nullptr)

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

  1203. 

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

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

  1206.     return false;

  1207. }

  1208. 

  1209. bool carla_patchbay_disconnect(uint connectionId)

  1210. {

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

  1212. 

  1213.     if (gStandalone.engine != nullptr)

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

  1215. 

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

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

  1218.     return false;

  1219. }

  1220. 

  1221. bool carla_patchbay_refresh()

  1222. {

  1223.     carla_debug("carla_patchbay_refresh()");

  1224. 

  1225.     if (gStandalone.engine != nullptr)

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

  1227. 

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

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

  1230.     return false;

  1231. }

  1232. #endif

  1233. 

  1234. // -------------------------------------------------------------------------------------------------------------------

  1235. 

  1236. void carla_transport_play()

  1237. {

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

  1239.     carla_debug("carla_transport_play()");

  1240. 

  1241.     gStandalone.engine->transportPlay();

  1242. }

  1243. 

  1244. void carla_transport_pause()

  1245. {

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

  1247.     carla_debug("carla_transport_pause()");

  1248. 

  1249.     gStandalone.engine->transportPause();

  1250. }

  1251. 

  1252. void carla_transport_relocate(uint64_t frame)

  1253. {

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

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

  1256. 

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

  1258. }

  1259. 

  1260. uint64_t carla_get_current_transport_frame()

  1261. {

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

  1263. 

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

  1265.     return timeInfo.frame;

  1266. }

  1267. 

  1268. const CarlaTransportInfo* carla_get_transport_info()

  1269. {

  1270.     static CarlaTransportInfo retInfo;

  1271. 

  1272.     // reset

  1273.     retInfo.playing = false;

  1274.     retInfo.frame   = 0;

  1275.     retInfo.bar     = 0;

  1276.     retInfo.beat    = 0;

  1277.     retInfo.tick    = 0;

  1278.     retInfo.bpm     = 0.0;

  1279. 

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

  1281. 

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

  1283. 

  1284.     retInfo.playing = timeInfo.playing;

  1285.     retInfo.frame   = timeInfo.frame;

  1286. 

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

  1288.     {

  1289.         retInfo.bar  = timeInfo.bbt.bar;

  1290.         retInfo.beat = timeInfo.bbt.beat;

  1291.         retInfo.tick = timeInfo.bbt.tick;

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

  1293.     }

  1294. 

  1295.     return &retInfo;

  1296. }

  1297. 

  1298. // -------------------------------------------------------------------------------------------------------------------

  1299. 

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

  1301. {

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

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

  1304. 

  1305.     if (gStandalone.engine != nullptr)

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

  1307. 

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

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

  1310.     return false;

  1311. }

  1312. 

  1313. bool carla_remove_plugin(uint pluginId)

  1314. {

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

  1316. 

  1317.     if (gStandalone.engine != nullptr)

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

  1319. 

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

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

  1322.     return false;

  1323. }

  1324. 

  1325. bool carla_remove_all_plugins()

  1326. {

  1327.     carla_debug("carla_remove_all_plugins()");

  1328. 

  1329.     if (gStandalone.engine != nullptr)

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

  1331. 

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

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

  1334.     return false;

  1335. }

  1336. 

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

  1338. {

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

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

  1341. 

  1342.     if (gStandalone.engine != nullptr)

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

  1344. 

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

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

  1347.     return nullptr;

  1348. }

  1349. 

  1350. bool carla_clone_plugin(uint pluginId)

  1351. {

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

  1353. 

  1354.     if (gStandalone.engine != nullptr)

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

  1356. 

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

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

  1359.     return false;

  1360. }

  1361. 

  1362. bool carla_replace_plugin(uint pluginId)

  1363. {

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

  1365. 

  1366.     if (gStandalone.engine != nullptr)

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

  1368. 

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

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

  1371.     return false;

  1372. }

  1373. 

  1374. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1375. {

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

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

  1378. 

  1379.     if (gStandalone.engine != nullptr)

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

  1381. 

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

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

  1384.     return false;

  1385. }

  1386. 

  1387. // -------------------------------------------------------------------------------------------------------------------

  1388. 

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

  1390. {

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

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

  1393. 

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

  1395.     {

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

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

  1398.         return false;

  1399.     }

  1400. 

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

  1402.         return plugin->loadStateFromFile(filename);

  1403. 

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

  1405.     return false;

  1406. }

  1407. 

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

  1409. {

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

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

  1412. 

  1413.     if (gStandalone.engine == nullptr)

  1414.     {

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

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

  1417.         return false;

  1418.     }

  1419. 

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

  1421. 

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

  1423.         return plugin->saveStateToFile(filename);

  1424. 

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

  1426.     return false;

  1427. }

  1428. 

  1429. // -------------------------------------------------------------------------------------------------------------------

  1430. 

  1431. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1432. {

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

  1434. 

  1435.     static CarlaPluginInfo info;

  1436. 

  1437.     // reset

  1438.     info.type             = CB::PLUGIN_NONE;

  1439.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1440.     info.hints            = 0x0;

  1441.     info.optionsAvailable = 0x0;

  1442.     info.optionsEnabled   = 0x0;

  1443.     info.filename         = gNullCharPtr;

  1444.     info.name             = gNullCharPtr;

  1445.     info.iconName         = gNullCharPtr;

  1446.     info.uniqueId         = 0;

  1447. 

  1448.     // cleanup

  1449.     if (info.label != gNullCharPtr)

  1450.     {

  1451.         delete[] info.label;

  1452.         info.label = gNullCharPtr;

  1453.     }

  1454. 

  1455.     if (info.maker != gNullCharPtr)

  1456.     {

  1457.         delete[] info.maker;

  1458.         info.maker = gNullCharPtr;

  1459.     }

  1460. 

  1461.     if (info.copyright != gNullCharPtr)

  1462.     {

  1463.         delete[] info.copyright;

  1464.         info.copyright = gNullCharPtr;

  1465.     }

  1466. 

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

  1468. 

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

  1470.     {

  1471.         char strBufLabel[STR_MAX+1];

  1472.         char strBufMaker[STR_MAX+1];

  1473.         char strBufCopyright[STR_MAX+1];

  1474. 

  1475.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1476.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1477.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1478. 

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

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

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

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

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

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

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

  1486. 

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

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

  1489. 

  1490.         plugin->getLabel(strBufLabel);

  1491.         info.label = carla_strdup(strBufLabel);

  1492. 

  1493.         plugin->getMaker(strBufMaker);

  1494.         info.maker = carla_strdup(strBufMaker);

  1495. 

  1496.         plugin->getCopyright(strBufCopyright);

  1497.         info.copyright = carla_strdup(strBufCopyright);

  1498. 

  1499.         checkStringPtr(info.filename);

  1500.         checkStringPtr(info.name);

  1501.         checkStringPtr(info.iconName);

  1502. 

  1503.         return &info;

  1504.     }

  1505. 

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

  1507.     return &info;

  1508. }

  1509. 

  1510. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1511. {

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

  1513. 

  1514.     static CarlaPortCountInfo info;

  1515. 

  1516.     // reset

  1517.     info.ins   = 0;

  1518.     info.outs  = 0;

  1519. 

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

  1521. 

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

  1523.     {

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

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

  1526.         return &info;

  1527.     }

  1528. 

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

  1530.     return &info;

  1531. }

  1532. 

  1533. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1534. {

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

  1536. 

  1537.     static CarlaPortCountInfo info;

  1538. 

  1539.     // reset

  1540.     info.ins   = 0;

  1541.     info.outs  = 0;

  1542. 

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

  1544. 

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

  1546.     {

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

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

  1549.         return &info;

  1550.     }

  1551. 

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

  1553.     return &info;

  1554. }

  1555. 

  1556. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1557. {

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

  1559. 

  1560.     static CarlaPortCountInfo info;

  1561. 

  1562.     // reset

  1563.     info.ins   = 0;

  1564.     info.outs  = 0;

  1565. 

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

  1567. 

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

  1569.     {

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

  1571.         return &info;

  1572.     }

  1573. 

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

  1575.     return &info;

  1576. }

  1577. 

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

  1579. {

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

  1581. 

  1582.     static CarlaParameterInfo info;

  1583. 

  1584.     // reset

  1585.     info.scalePointCount = 0;

  1586. 

  1587.     // cleanup

  1588.     if (info.name != gNullCharPtr)

  1589.     {

  1590.         delete[] info.name;

  1591.         info.name = gNullCharPtr;

  1592.     }

  1593. 

  1594.     if (info.symbol != gNullCharPtr)

  1595.     {

  1596.         delete[] info.symbol;

  1597.         info.symbol = gNullCharPtr;

  1598.     }

  1599. 

  1600.     if (info.unit != gNullCharPtr)

  1601.     {

  1602.         delete[] info.unit;

  1603.         info.unit = gNullCharPtr;

  1604.     }

  1605. 

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

  1607. 

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

  1609.     {

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

  1611.         {

  1612.             char strBufName[STR_MAX+1];

  1613.             char strBufSymbol[STR_MAX+1];

  1614.             char strBufUnit[STR_MAX+1];

  1615. 

  1616.             carla_zeroChar(strBufName, STR_MAX+1);

  1617.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1618.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1619. 

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

  1621. 

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

  1623.             info.name = carla_strdup(strBufName);

  1624. 

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

  1626.             info.symbol = carla_strdup(strBufSymbol);

  1627. 

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

  1629.             info.unit = carla_strdup(strBufUnit);

  1630.         }

  1631.         else

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

  1633. 

  1634.         return &info;

  1635.     }

  1636. 

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

  1638.     return &info;

  1639. }

  1640. 

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

  1642. {

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

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

  1645. 

  1646.     static CarlaScalePointInfo info;

  1647. 

  1648.     // reset

  1649.     info.value = 0.0f;

  1650. 

  1651.     // cleanup

  1652.     if (info.label != gNullCharPtr)

  1653.     {

  1654.         delete[] info.label;

  1655.         info.label = gNullCharPtr;

  1656.     }

  1657. 

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

  1659. 

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

  1661.     {

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

  1663.         {

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

  1665.             {

  1666.                 char strBufLabel[STR_MAX+1];

  1667.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1668. 

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

  1670. 

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

  1672.                 info.label = carla_strdup(strBufLabel);

  1673.             }

  1674.             else

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

  1676.         }

  1677.         else

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

  1679. 

  1680.         return &info;

  1681.     }

  1682. 

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

  1684.     return &info;

  1685. }

  1686. 

  1687. // -------------------------------------------------------------------------------------------------------------------

  1688. 

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

  1690. {

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

  1692. 

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

  1694. 

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

  1696. 

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

  1698.     {

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

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

  1701. 

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

  1703.         return &fallbackParameterData;

  1704.     }

  1705. 

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

  1707.     return &fallbackParameterData;

  1708. }

  1709. 

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

  1711. {

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

  1713. 

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

  1715. 

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

  1717. 

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

  1719.     {

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

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

  1722. 

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

  1724.         return &fallbackParamRanges;

  1725.     }

  1726. 

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

  1728.     return &fallbackParamRanges;

  1729. }

  1730. 

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

  1732. {

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

  1734. 

  1735.     static MidiProgramData midiProgData;

  1736. 

  1737.     // reset

  1738.     midiProgData.bank    = 0;

  1739.     midiProgData.program = 0;

  1740.     midiProgData.name    = gNullCharPtr;

  1741. 

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

  1743. 

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

  1745.     {

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

  1747.         {

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

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

  1750.             checkStringPtr(midiProgData.name);

  1751.             return &midiProgData;

  1752.         }

  1753. 

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

  1755.         return &midiProgData;

  1756.     }

  1757. 

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

  1759.     return &midiProgData;

  1760. }

  1761. 

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

  1763. {

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

  1765. 

  1766.     static CustomData customData;

  1767. 

  1768.     // reset

  1769.     customData.type  = gNullCharPtr;

  1770.     customData.key   = gNullCharPtr;

  1771.     customData.value = gNullCharPtr;

  1772. 

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

  1774. 

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

  1776.     {

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

  1778.         {

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

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

  1781.             checkStringPtr(customData.type);

  1782.             checkStringPtr(customData.key);

  1783.             checkStringPtr(customData.value);

  1784.             return &customData;

  1785.         }

  1786. 

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

  1788.         return &customData;

  1789.     }

  1790. 

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

  1792.     return &customData;

  1793. }

  1794. 

  1795. const char* carla_get_chunk_data(uint pluginId)

  1796. {

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

  1798. 

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

  1800. 

  1801.     static CarlaString chunkData;

  1802. 

  1803.     // cleanup

  1804.     chunkData.clear();

  1805. 

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

  1807.     {

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

  1809.         {

  1810.             void* data = nullptr;

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

  1812. 

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

  1814.             {

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

  1816. 

  1817.                 return chunkData;

  1818.             }

  1819.             else

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

  1821.         }

  1822.         else

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

  1824. 

  1825.         return nullptr;

  1826.     }

  1827. 

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

  1829.     return nullptr;

  1830. }

  1831. 

  1832. // -------------------------------------------------------------------------------------------------------------------

  1833. 

  1834. uint32_t carla_get_parameter_count(uint pluginId)

  1835. {

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

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

  1838. 

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

  1840.         return plugin->getParameterCount();

  1841. 

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

  1843.     return 0;

  1844. }

  1845. 

  1846. uint32_t carla_get_program_count(uint pluginId)

  1847. {

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

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

  1850. 

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

  1852.         return plugin->getProgramCount();

  1853. 

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

  1855.     return 0;

  1856. }

  1857. 

  1858. uint32_t carla_get_midi_program_count(uint pluginId)

  1859. {

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

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

  1862. 

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

  1864.         return plugin->getMidiProgramCount();

  1865. 

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

  1867.     return 0;

  1868. }

  1869. 

  1870. uint32_t carla_get_custom_data_count(uint pluginId)

  1871. {

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

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

  1874. 

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

  1876.         return plugin->getCustomDataCount();

  1877. 

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

  1879.     return 0;

  1880. }

  1881. 

  1882. // -------------------------------------------------------------------------------------------------------------------

  1883. 

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

  1885. {

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

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

  1888. 

  1889.     static char textBuf[STR_MAX+1];

  1890. 

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

  1892.     {

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

  1894.         {

  1895.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1897.             return textBuf;

  1898.         }

  1899. 

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

  1901.         return nullptr;

  1902.     }

  1903. 

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

  1905.     return nullptr;

  1906. }

  1907. 

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

  1909. {

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

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

  1912. 

  1913.     static char programName[STR_MAX+1];

  1914. 

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

  1916.     {

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

  1918.         {

  1919.             carla_zeroChar(programName, STR_MAX+1);

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

  1921.             return programName;

  1922.         }

  1923. 

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

  1925.         return nullptr;

  1926.     }

  1927. 

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

  1929.     return nullptr;

  1930. }

  1931. 

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

  1933. {

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

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

  1936. 

  1937.     static char midiProgramName[STR_MAX+1];

  1938. 

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

  1940.     {

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

  1942.         {

  1943.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1945.             return midiProgramName;

  1946.         }

  1947. 

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

  1949.         return nullptr;

  1950.     }

  1951. 

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

  1953.     return nullptr;

  1954. }

  1955. 

  1956. const char* carla_get_real_plugin_name(uint pluginId)

  1957. {

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

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

  1960. 

  1961.     static char realPluginName[STR_MAX+1];

  1962. 

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

  1964.     {

  1965.         carla_zeroChar(realPluginName, STR_MAX+1);

  1966.         plugin->getRealName(realPluginName);

  1967.         return realPluginName;

  1968.     }

  1969. 

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

  1971.     return nullptr;

  1972. }

  1973. 

  1974. // -------------------------------------------------------------------------------------------------------------------

  1975. 

  1976. int32_t carla_get_current_program_index(uint pluginId)

  1977. {

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

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

  1980. 

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

  1982.         return plugin->getCurrentProgram();

  1983. 

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

  1985.     return -1;

  1986. }

  1987. 

  1988. int32_t carla_get_current_midi_program_index(uint pluginId)

  1989. {

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

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

  1992. 

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

  1994.         return plugin->getCurrentMidiProgram();

  1995. 

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

  1997.     return -1;

  1998. }

  1999. 

  2000. // -------------------------------------------------------------------------------------------------------------------

  2001. 

  2002. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  2003. {

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

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

  2006. 

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

  2008.     {

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

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

  2011. 

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

  2013.         return 0.0f;

  2014.     }

  2015. 

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

  2017.     return 0.0f;

  2018. }

  2019. 

  2020. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  2021. {

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

  2023. 

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

  2025.     {

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

  2027.             return plugin->getParameterValue(parameterId);

  2028. 

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

  2030.         return 0.0f;

  2031.     }

  2032. 

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

  2034.     return 0.0f;

  2035. }

  2036. 

  2037. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  2038. {

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

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

  2041. 

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

  2043.         return plugin->getInternalParameterValue(parameterId);

  2044. 

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

  2046.     return 0.0f;

  2047. }

  2048. 

  2049. // -------------------------------------------------------------------------------------------------------------------

  2050. 

  2051. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  2052. {

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

  2054. 

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

  2056. }

  2057. 

  2058. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  2059. {

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

  2061. 

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

  2063. }

  2064. 

  2065. // -------------------------------------------------------------------------------------------------------------------

  2066. 

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

  2068. {

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

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

  2071. 

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

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

  2074. 

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

  2076. }

  2077. 

  2078. void carla_set_active(uint pluginId, bool onOff)

  2079. {

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

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

  2082. 

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

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

  2085. 

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

  2087. }

  2088. 

  2089. #ifndef BUILD_BRIDGE

  2090. void carla_set_drywet(uint pluginId, float value)

  2091. {

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

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

  2094. 

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

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

  2097. 

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

  2099. }

  2100. 

  2101. void carla_set_volume(uint pluginId, float value)

  2102. {

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

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

  2105. 

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

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

  2108. 

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

  2110. }

  2111. 

  2112. void carla_set_balance_left(uint pluginId, float value)

  2113. {

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

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

  2116. 

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

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

  2119. 

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

  2121. }

  2122. 

  2123. void carla_set_balance_right(uint pluginId, float value)

  2124. {

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

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

  2127. 

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

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

  2130. 

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

  2132. }

  2133. 

  2134. void carla_set_panning(uint pluginId, float value)

  2135. {

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

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

  2138. 

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

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

  2141. 

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

  2143. }

  2144. #endif

  2145. 

  2146. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  2147. {

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

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

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

  2151. 

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

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

  2154. 

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

  2156. }

  2157. 

  2158. // -------------------------------------------------------------------------------------------------------------------

  2159. 

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

  2161. {

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

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

  2164. 

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

  2166.     {

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

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

  2169. 

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

  2171.         return;

  2172.     }

  2173. 

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

  2175. }

  2176. 

  2177. #ifndef BUILD_BRIDGE

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

  2179. {

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

  2181.     CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);

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

  2183. 

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

  2185.     {

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

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

  2188. 

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

  2190.         return;

  2191.     }

  2192. 

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

  2194. }

  2195. 

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

  2197. {

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

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

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

  2201. 

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

  2203.     {

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

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

  2206. 

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

  2208.         return;

  2209.     }

  2210. 

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

  2212. }

  2213. #endif

  2214. 

  2215. // -------------------------------------------------------------------------------------------------------------------

  2216. 

  2217. void carla_set_program(uint pluginId, uint32_t programId)

  2218. {

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

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

  2221. 

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

  2223.     {

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

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

  2226. 

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

  2228.         return;

  2229.     }

  2230. 

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

  2232. }

  2233. 

  2234. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2235. {

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

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

  2238. 

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

  2240.     {

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

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

  2243. 

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

  2245.         return;

  2246.     }

  2247. 

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

  2249. }

  2250. 

  2251. // -------------------------------------------------------------------------------------------------------------------

  2252. 

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

  2254. {

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

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

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

  2258.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2260. 

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

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

  2263. 

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

  2265. }

  2266. 

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

  2268. {

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

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

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

  2272. 

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

  2274.     {

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

  2276.             return plugin->setChunkData(chunkData);

  2277. 

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

  2279.         return;

  2280.     }

  2281. 

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

  2283. }

  2284. 

  2285. // -------------------------------------------------------------------------------------------------------------------

  2286. 

  2287. void carla_prepare_for_save(uint pluginId)

  2288. {

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

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

  2291. 

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

  2293.         return plugin->prepareForSave();

  2294. 

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

  2296. }

  2297. 

  2298. void carla_reset_parameters(uint pluginId)

  2299. {

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

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

  2302. 

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

  2304.         return plugin->resetParameters();

  2305. 

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

  2307. }

  2308. 

  2309. void carla_randomize_parameters(uint pluginId)

  2310. {

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

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

  2313. 

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

  2315.         return plugin->randomizeParameters();

  2316. 

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

  2318. }

  2319. 

  2320. #ifndef BUILD_BRIDGE

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

  2322. {

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

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

  2325. 

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

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

  2328. 

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

  2330. }

  2331. #endif

  2332. 

  2333. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2334. {

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

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

  2337. 

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

  2339.         return plugin->showCustomUI(yesNo);

  2340. 

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

  2342. }

  2343. 

  2344. // -------------------------------------------------------------------------------------------------------------------

  2345. 

  2346. uint32_t carla_get_buffer_size()

  2347. {

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

  2349.     carla_debug("carla_get_buffer_size()");

  2350. 

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

  2352. }

  2353. 

  2354. double carla_get_sample_rate()

  2355. {

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

  2357.     carla_debug("carla_get_sample_rate()");

  2358. 

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

  2360. }

  2361. 

  2362. // -------------------------------------------------------------------------------------------------------------------

  2363. 

  2364. const char* carla_get_last_error()

  2365. {

  2366.     carla_debug("carla_get_last_error()");

  2367. 

  2368.     if (gStandalone.engine != nullptr)

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

  2370. 

  2371.     return gStandalone.lastError;

  2372. }

  2373. 

  2374. const char* carla_get_host_osc_url_tcp()

  2375. {

  2376.     carla_debug("carla_get_host_osc_url_tcp()");

  2377. 

  2378.     if (gStandalone.engine == nullptr)

  2379.     {

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

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

  2382.         return nullptr;

  2383.     }

  2384. 

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

  2386. }

  2387. 

  2388. const char* carla_get_host_osc_url_udp()

  2389. {

  2390.     carla_debug("carla_get_host_osc_url_udp()");

  2391. 

  2392.     if (gStandalone.engine == nullptr)

  2393.     {

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

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

  2396.         return nullptr;

  2397.     }

  2398. 

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

  2400. }

  2401. 

  2402. // -------------------------------------------------------------------------------------------------------------------

  2403. 

  2404. #ifdef WANT_DSSI

  2405. # include "CarlaDssiUtils.cpp"

  2406. #endif

  2407. 

  2408. #include "CarlaStateUtils.cpp"

  2409. 

  2410. #if 0

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

  2412. {

  2413.     return 0;

  2414. }

  2415. #endif

  2416. 

  2417. // -------------------------------------------------------------------------------------------------------------------