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.
1662 Commits
16 Branches
153MB
Tree: 2c470a9aab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2c470a9aab'
${ noResults }
Carla/source/backend/standalone/CarlaStandalone.cpp

2389 lines
78KB
Raw Blame History 

  1. /*

  2.  * Carla Standalone

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. // TODO:

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

  20. 

  21. #include "CarlaHost.h"

  22. #include "CarlaMIDI.h"

  23. #include "CarlaNative.h"

  24. 

  25. #include "CarlaEngine.hpp"

  26. #include "CarlaPlugin.hpp"

  27. 

  28. #include "CarlaBackendUtils.hpp"

  29. #include "CarlaOscUtils.hpp"

  30. 

  31. #include <QtCore/QByteArray>

  32. 

  33. #ifdef BUILD_BRIDGE

  34. # undef HAVE_JUCE

  35. #endif

  36. 

  37. #ifdef HAVE_JUCE

  38. # include "juce_gui_basics.h"

  39. using juce::initialiseJuce_GUI;

  40. using juce::shutdownJuce_GUI;

  41. using juce::MessageManager;

  42. #endif

  43. 

  44. namespace CB = CarlaBackend;

  45. using CB::EngineOptions;

  46. 

  47. // -------------------------------------------------------------------------------------------------------------------

  48. // Juce Message Thread

  49. 

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

  51. 

  52. class JuceMessageThread : public juce::Thread

  53. {

  54. public:

  55.     JuceMessageThread()

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

  57.         fInitialised(false)

  58.     {

  59.     }

  60. 

  61.     ~JuceMessageThread() override

  62.     {

  63.         stop();

  64.     }

  65. 

  66.     void start()

  67.     {

  68.         CARLA_SAFE_ASSERT_RETURN(! fInitialised,);

  69. 

  70.         fInitialised = false;

  71. 

  72.         startThread();

  73. 

  74.         while (! fInitialised)

  75.             Thread::sleep(1);

  76.     }

  77. 

  78.     void stop()

  79.     {

  80.         if (! fInitialised)

  81.             return;

  82. 

  83.         stopThread(-1);

  84.     }

  85. 

  86. protected:

  87.     void run() override

  88.     {

  89.         fInitialised = true;

  90. 

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

  92.         {

  93.             msgMgr->setCurrentThreadAsMessageThread();

  94. 

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

  96.         }

  97. 

  98.         fInitialised = false;

  99.     }

  100. 

  101. private:

  102.     volatile bool fInitialised;

  103. 

  104.     CARLA_DECLARE_NON_COPY_CLASS(JuceMessageThread)

  105. };

  106. 

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

  108. 

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

  110. // Single, standalone engine

  111. 

  112. struct CarlaBackendStandalone {

  113.     CarlaEngine*       engine;

  114.     EngineCallbackFunc engineCallback;

  115.     void*              engineCallbackPtr;

  116.     EngineOptions      engineOptions;

  117. 

  118.     FileCallbackFunc fileCallback;

  119.     void*            fileCallbackPtr;

  120. 

  121.     CarlaString lastError;

  122. 

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

  124.     JuceMessageThread juceMsgThread;

  125. #endif

  126. 

  127.     CarlaBackendStandalone()

  128.         : engine(nullptr),

  129.           engineCallback(nullptr),

  130.           engineCallbackPtr(nullptr),

  131.           fileCallback(nullptr),

  132.           fileCallbackPtr(nullptr)

  133.     {

  134. #ifdef BUILD_BRIDGE

  135.         engineOptions.processMode         = CB::ENGINE_PROCESS_MODE_BRIDGE;

  136.         engineOptions.transportMode       = CB::ENGINE_TRANSPORT_MODE_BRIDGE;

  137.         engineOptions.forceStereo         = false;

  138.         engineOptions.preferPluginBridges = false;

  139.         engineOptions.preferUiBridges     = false;

  140. #endif

  141.     }

  142. 

  143.     ~CarlaBackendStandalone()

  144.     {

  145.         CARLA_SAFE_ASSERT(engine == nullptr);

  146. #ifdef HAVE_JUCE

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

  148. #endif

  149.     }

  150. 

  151. #ifdef HAVE_JUCE

  152.     void init()

  153.     {

  154.         JUCE_AUTORELEASEPOOL

  155.         {

  156.             initialiseJuce_GUI();

  157. # ifdef CARLA_OS_LINUX

  158.             juceMsgThread.start();

  159. # else

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

  161.                 msgMgr->setCurrentThreadAsMessageThread();

  162. # endif

  163.         }

  164.     }

  165. 

  166.     void close()

  167.     {

  168.         JUCE_AUTORELEASEPOOL

  169.         {

  170. # ifdef CARLA_OS_LINUX

  171.             juceMsgThread.stop();

  172. # else

  173.             MessageManager::deleteInstance();

  174. # endif

  175.             shutdownJuce_GUI();

  176.         }

  177.     }

  178. 

  179. # ifndef CARLA_OS_LINUX

  180.     void idle()

  181.     {

  182.         JUCE_AUTORELEASEPOOL

  183.         {

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

  185.                 msgMgr->runDispatchLoopUntil(5);

  186.         }

  187.     }

  188. # endif

  189. #endif

  190. 

  191.     CARLA_PREVENT_HEAP_ALLOCATION

  192.     CARLA_DECLARE_NON_COPY_STRUCT(CarlaBackendStandalone)

  193. };

  194. 

  195. static CarlaBackendStandalone gStandalone;

  196. 

  197. // -------------------------------------------------------------------------------------------------------------------

  198. // NSM support

  199. 

  200. #define NSM_API_VERSION_MAJOR 1

  201. #define NSM_API_VERSION_MINOR 2

  202. 

  203. #ifdef HAVE_X11

  204. # define NSM_CLIENT_FEATURES ":switch:optional-gui:"

  205. #else

  206. # define NSM_CLIENT_FEATURES ":switch:"

  207. #endif

  208. 

  209. class CarlaNSM

  210. {

  211. public:

  212.     CarlaNSM() noexcept

  213.         : fOscServer(nullptr) {}

  214. 

  215.     ~CarlaNSM()

  216.     {

  217.         if (fOscServer != nullptr)

  218.         {

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

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

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

  222.             lo_server_free(fOscServer);

  223.             fOscServer = nullptr;

  224.         }

  225.     }

  226. 

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

  228.     {

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

  230. 

  231.         if (NSM_URL == nullptr)

  232.             return;

  233. 

  234.         const lo_address addr = lo_address_new_from_url(NSM_URL);

  235. 

  236.         if (addr == nullptr)

  237.             return;

  238. 

  239.         const int proto = lo_address_get_protocol(addr);

  240. 

  241.         if (fOscServer == nullptr)

  242.         {

  243.             // create new OSC server

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

  245. 

  246.             // register message handlers and start OSC thread

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

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

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

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

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

  252.             // /nsm/client/session_is_loaded

  253.         }

  254. 

  255. #ifndef BUILD_ANSI_TEST

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

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

  258. #endif

  259. 

  260.         lo_address_free(addr);

  261.     }

  262. 

  263.     void idle() noexcept

  264.     {

  265.         if (fOscServer == nullptr)

  266.             return;

  267. 

  268.         for (;;)

  269.         {

  270.             try {

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

  272.                     break;

  273.             }

  274.             CARLA_SAFE_EXCEPTION_CONTINUE("NSM OSC idle")

  275.         }

  276.     }

  277. 

  278. protected:

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

  280.     {

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

  282. 

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

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

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

  286. 

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

  288. 

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

  290. 

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

  292. 

  293.         return 0;

  294. 

  295. #ifndef DEBUG

  296.         // unused

  297.         (void)path; (void)types; (void)argc;

  298. #endif

  299.     }

  300. 

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

  302.     {

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

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

  305. 

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

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

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

  309. 

  310.         if (! carla_is_engine_running())

  311.         {

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

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

  314. 

  315.             carla_engine_init("JACK", clientId);

  316.         }

  317.         else

  318.         {

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

  320. 

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

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

  323.         }

  324. 

  325.         fProjectPath  = projectPath;

  326.         fProjectPath += ".carxp";

  327. 

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

  329. 

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

  331. 

  332. #ifndef BUILD_ANSI_TEST

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

  334. #endif

  335. 

  336.         return 0;

  337. 

  338. #ifndef DEBUG

  339.         // unused

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

  341. #endif

  342.     }

  343. 

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

  345.     {

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

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

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

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

  350. 

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

  352. 

  353. #ifndef BUILD_ANSI_TEST

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

  355. #endif

  356. 

  357.         return 0;

  358. 

  359. #ifndef DEBUG

  360.         // unused

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

  362. #endif

  363.     }

  364. 

  365.     int handleShowHideGui(const bool show)

  366.     {

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

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

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

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

  371. 

  372. #ifdef HAVE_X11

  373. #endif

  374. 

  375. #ifndef BUILD_ANSI_TEST

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

  377. #endif

  378. 

  379.         return 0;

  380.     }

  381. 

  382. private:

  383.     lo_server   fOscServer;

  384.     CarlaString fProjectPath;

  385. 

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

  387. 

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

  389.     {

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

  391.     }

  392. 

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

  394.     {

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

  396.     }

  397. 

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

  399.     {

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

  401.     }

  402. 

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

  404.     {

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

  406.     }

  407. 

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

  409.     {

  410.         return handlePtr->handleShowHideGui(true);

  411.     }

  412. 

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

  414.     {

  415.         return handlePtr->handleShowHideGui(false);

  416.     }

  417. 

  418.     #undef handlePtr

  419. 

  420.     CARLA_PREVENT_HEAP_ALLOCATION

  421.     CARLA_DECLARE_NON_COPY_CLASS(CarlaNSM)

  422. };

  423. 

  424. static CarlaNSM gNSM;

  425. 

  426. // -------------------------------------------------------------------------------------------------------------------

  427. // Always return a valid string ptr

  428. 

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

  430. 

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

  432. {

  433.     if (charPtr == nullptr)

  434.         charPtr = gNullCharPtr;

  435. }

  436. 

  437. // -------------------------------------------------------------------------------------------------------------------

  438. // Constructors

  439. 

  440. _CarlaPluginInfo::_CarlaPluginInfo() noexcept

  441.     : type(CB::PLUGIN_NONE),

  442.       category(CB::PLUGIN_CATEGORY_NONE),

  443.       hints(0x0),

  444.       optionsAvailable(0x0),

  445.       optionsEnabled(0x0),

  446.       filename(gNullCharPtr),

  447.       name(gNullCharPtr),

  448.       label(gNullCharPtr),

  449.       maker(gNullCharPtr),

  450.       copyright(gNullCharPtr),

  451.       iconName(gNullCharPtr),

  452.       uniqueId(0) {}

  453. 

  454. _CarlaPluginInfo::~_CarlaPluginInfo() noexcept

  455. {

  456.     if (label != gNullCharPtr)

  457.         delete[] label;

  458.     if (maker != gNullCharPtr)

  459.         delete[] maker;

  460.     if (copyright != gNullCharPtr)

  461.         delete[] copyright;

  462. }

  463. 

  464. _CarlaNativePluginInfo::_CarlaNativePluginInfo() noexcept

  465.     : category(CB::PLUGIN_CATEGORY_NONE),

  466.       hints(0x0),

  467.       audioIns(0),

  468.       audioOuts(0),

  469.       midiIns(0),

  470.       midiOuts(0),

  471.       parameterIns(0),

  472.       parameterOuts(0),

  473.       name(gNullCharPtr),

  474.       label(gNullCharPtr),

  475.       maker(gNullCharPtr),

  476.       copyright(gNullCharPtr) {}

  477. 

  478. _CarlaParameterInfo::_CarlaParameterInfo() noexcept

  479.     : name(gNullCharPtr),

  480.       symbol(gNullCharPtr),

  481.       unit(gNullCharPtr),

  482.       scalePointCount(0) {}

  483. 

  484. _CarlaParameterInfo::~_CarlaParameterInfo() noexcept

  485. {

  486.     if (name != gNullCharPtr)

  487.         delete[] name;

  488.     if (symbol != gNullCharPtr)

  489.         delete[] symbol;

  490.     if (unit != gNullCharPtr)

  491.         delete[] unit;

  492. }

  493. 

  494. _CarlaScalePointInfo::_CarlaScalePointInfo() noexcept

  495.     : value(0.0f),

  496.       label(gNullCharPtr) {}

  497. 

  498. _CarlaScalePointInfo::~_CarlaScalePointInfo() noexcept

  499. {

  500.     if (label != gNullCharPtr)

  501.         delete[] label;

  502. }

  503. 

  504. _CarlaTransportInfo::_CarlaTransportInfo() noexcept

  505.     : playing(false),

  506.       frame(0),

  507.       bar(0),

  508.       beat(0),

  509.       tick(0),

  510.       bpm(0.0) {}

  511. 

  512. // -------------------------------------------------------------------------------------------------------------------

  513. // API

  514. 

  515. const char* carla_get_complete_license_text()

  516. {

  517.     carla_debug("carla_get_complete_license_text()");

  518. 

  519.     static CarlaString retText;

  520. 

  521.     if (retText.isEmpty())

  522.     {

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

  524. 

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

  526.         text1 += "<ul>";

  527. 

  528.         // Plugin formats

  529. #ifdef WANT_LADSPA

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

  531. #endif

  532. #ifdef WANT_DSSI

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

  534. #endif

  535. #ifdef WANT_LV2

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

  537. #endif

  538. #ifdef WANT_VST

  539. # ifdef VESTIGE_HEADER

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

  541. # else

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

  543. # endif

  544. #endif

  545. #ifdef WANT_AU

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

  547. #endif

  548. 

  549.         // Files

  550. #ifdef WANT_CSOUND

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

  552. #endif

  553. 

  554.         // Sample kit libraries

  555. #ifdef WANT_FLUIDSYNTH

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

  557. #endif

  558. #ifdef WANT_LINUXSAMPLER

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

  560. #endif

  561. 

  562. #ifdef WANT_NATIVE

  563.         // Internal plugins

  564. # ifdef HAVE_OPENGL

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

  566. # endif

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

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

  569. # ifdef WANT_AUDIOFILE

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

  571. # endif

  572. # ifdef WANT_MIDIFILE

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

  574. # endif

  575. # ifdef WANT_ZYNADDSUBFX

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

  577. #  ifdef WANT_ZYNADDSUBFX_UI

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

  579. #  endif

  580. # endif

  581. #endif

  582. 

  583.         // misc libs

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

  585. #ifdef WANT_LV2

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

  587. #endif

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

  589. 

  590.         // end

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

  592. 

  593.         // code snippets

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

  595.         text5 += "<ul>";

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

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

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

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

  600. 

  601. #ifdef WANT_LINUXSAMPLER

  602.         // LinuxSampler GPL exception

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

  604. #endif

  605. 

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

  607.     }

  608. 

  609.     return retText;

  610. }

  611. 

  612. const char* carla_get_supported_file_extensions()

  613. {

  614.     carla_debug("carla_get_supported_file_extensions()");

  615. 

  616.     static CarlaString retText;

  617. 

  618.     if (retText.isEmpty())

  619.     {

  620.         // Base types

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

  622. 

  623.         // CSound

  624. #ifdef WANT_CSOUND

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

  626. #endif

  627. 

  628.         // Sample kits

  629. #ifdef WANT_FLUIDSYNTH

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

  631. #endif

  632. #ifdef WANT_LINUXSAMPLER

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

  634. #endif

  635. 

  636.         // Files provided by internal plugins

  637. #ifdef WANT_AUDIOFILE

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

  639. # ifdef HAVE_FFMPEG

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

  641. # endif

  642. #endif

  643. #ifdef WANT_MIDIFILE

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

  645. #endif

  646. 

  647.         // Plugin presets

  648. #ifdef WANT_ZYNADDSUBFX

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

  650. #endif

  651.     }

  652. 

  653.     return retText;

  654. }

  655. 

  656. // -------------------------------------------------------------------------------------------------------------------

  657. 

  658. unsigned int carla_get_engine_driver_count()

  659. {

  660.     carla_debug("carla_get_engine_driver_count()");

  661. 

  662.     return CarlaEngine::getDriverCount();

  663. }

  664. 

  665. const char* carla_get_engine_driver_name(unsigned int index)

  666. {

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

  668. 

  669.     return CarlaEngine::getDriverName(index);

  670. }

  671. 

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

  673. {

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

  675. 

  676.     return CarlaEngine::getDriverDeviceNames(index);

  677. }

  678. 

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

  680. {

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

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

  683. 

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

  685.     {

  686.         static EngineDriverDeviceInfo devInfo;

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

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

  689. 

  690.         devInfo.hints       = ret->hints;

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

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

  693.         return &devInfo;

  694.     }

  695. 

  696.     return nullptr;

  697. }

  698. 

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

  700. 

  701. unsigned int carla_get_internal_plugin_count()

  702. {

  703.     carla_debug("carla_get_internal_plugin_count()");

  704. 

  705. #ifdef WANT_NATIVE

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

  707. #else

  708.     return 0;

  709. #endif

  710. }

  711. 

  712. const CarlaNativePluginInfo* carla_get_internal_plugin_info(unsigned int index)

  713. {

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

  715. 

  716. #ifdef WANT_NATIVE

  717.     static CarlaNativePluginInfo info;

  718. 

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

  720. 

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

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

  723. 

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

  725.      info.hints    = 0x0;

  726. 

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

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

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

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

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

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

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

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

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

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

  737. 

  738.      info.audioIns  = nativePlugin->audioIns;

  739.      info.audioOuts = nativePlugin->audioOuts;

  740.      info.midiIns   = nativePlugin->midiIns;

  741.      info.midiOuts  = nativePlugin->midiOuts;

  742.      info.parameterIns  = nativePlugin->paramIns;

  743.      info.parameterOuts = nativePlugin->paramOuts;

  744. 

  745.      info.name      = nativePlugin->name;

  746.      info.label     = nativePlugin->label;

  747.      info.maker     = nativePlugin->maker;

  748.      info.copyright = nativePlugin->copyright;

  749. 

  750.      checkStringPtr(info.name);

  751.      checkStringPtr(info.label);

  752.      checkStringPtr(info.maker);

  753.      checkStringPtr(info.copyright);

  754. 

  755.     return &info;

  756. #else

  757.     return nullptr;

  758. 

  759.     // unused

  760.     (void)index;

  761. #endif

  762. }

  763. 

  764. // -------------------------------------------------------------------------------------------------------------------

  765. 

  766. const CarlaEngine* carla_get_engine()

  767. {

  768.     carla_debug("carla_get_engine()");

  769. 

  770.     return gStandalone.engine;

  771. }

  772. 

  773. // -------------------------------------------------------------------------------------------------------------------

  774. 

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

  776. {

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

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

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

  780. 

  781.     if (gStandalone.engine != nullptr)

  782.     {

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

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

  785.         return false;

  786.     }

  787. 

  788. #ifdef CARLA_OS_WIN

  789.     carla_setenv("WINEASIO_CLIENT_NAME", clientName);

  790. #endif

  791. 

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

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

  794.     {

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

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

  797.     }

  798. 

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

  800. 

  801.     if (gStandalone.engine == nullptr)

  802.     {

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

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

  805.         return false;

  806.     }

  807. 

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

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

  810. 

  811. #ifdef BUILD_BRIDGE

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

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

  814. #else

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

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

  817. #endif

  818. 

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

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

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

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

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

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

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

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

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

  828. 

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

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

  831. 

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

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

  834. 

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

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

  837. 

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

  839.     {

  840.         char strBuf[STR_MAX+1];

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

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

  843.     }

  844.     else

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

  846. 

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

  848.     {

  849.         gStandalone.lastError = "No error";

  850. #ifdef HAVE_JUCE

  851.         gStandalone.init();

  852. #endif

  853.         return true;

  854.     }

  855.     else

  856.     {

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

  858.         delete gStandalone.engine;

  859.         gStandalone.engine = nullptr;

  860.         return false;

  861.     }

  862. }

  863. 

  864. #ifdef BUILD_BRIDGE

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

  866. {

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

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

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

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

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

  872. 

  873.     if (gStandalone.engine != nullptr)

  874.     {

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

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

  877.         return false;

  878.     }

  879. 

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

  881. 

  882.     if (gStandalone.engine == nullptr)

  883.     {

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

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

  886.         return false;

  887.     }

  888. 

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

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

  891. 

  892.     // forced options for bridge mode

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

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

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

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

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

  898. 

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

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

  901. 

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

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

  904. 

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

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

  907. 

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

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

  910. 

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

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

  913. 

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

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

  916. 

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

  918.     {

  919.         gStandalone.lastError = "No error";

  920. #ifdef HAVE_JUCE

  921.         gStandalone.init();

  922. #endif

  923.         return true;

  924.     }

  925.     else

  926.     {

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

  928.         delete gStandalone.engine;

  929.         gStandalone.engine = nullptr;

  930.         return false;

  931.     }

  932. }

  933. #endif

  934. 

  935. bool carla_engine_close()

  936. {

  937.     carla_debug("carla_engine_close()");

  938. 

  939.     if (gStandalone.engine == nullptr)

  940.     {

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

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

  943.         return false;

  944.     }

  945. 

  946.     gStandalone.engine->setAboutToClose();

  947.     gStandalone.engine->removeAllPlugins();

  948. 

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

  950. 

  951.     if (! closed)

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

  953. 

  954. #ifdef HAVE_JUCE

  955.     gStandalone.close();

  956. #endif

  957. 

  958.     delete gStandalone.engine;

  959.     gStandalone.engine = nullptr;

  960. 

  961.     return closed;

  962. }

  963. 

  964. void carla_engine_idle()

  965. {

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

  967. 

  968.     gNSM.idle();

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

  970.     gStandalone.idle();

  971. #endif

  972.     gStandalone.engine->idle();

  973. }

  974. 

  975. bool carla_is_engine_running()

  976. {

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

  978. }

  979. 

  980. void carla_set_engine_about_to_close()

  981. {

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

  983.     carla_debug("carla_set_engine_about_to_close()");

  984. 

  985.     gStandalone.engine->setAboutToClose();

  986. }

  987. 

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

  989. {

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

  991. 

  992.     gStandalone.engineCallback    = func;

  993.     gStandalone.engineCallbackPtr = ptr;

  994. 

  995.     if (gStandalone.engine != nullptr)

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

  997. 

  998. //#ifdef WANT_LOGS

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

  1000. //#endif

  1001. }

  1002. 

  1003. #ifndef BUILD_BRIDGE

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

  1005. {

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

  1007. 

  1008.     switch (option)

  1009.     {

  1010.     case CB::ENGINE_OPTION_DEBUG:

  1011.         break;

  1012. 

  1013.     case CB::ENGINE_OPTION_PROCESS_MODE:

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

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

  1016.         break;

  1017. 

  1018.     case CB::ENGINE_OPTION_TRANSPORT_MODE:

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

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

  1021.         break;

  1022. 

  1023.     case CB::ENGINE_OPTION_FORCE_STEREO:

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

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

  1026.         break;

  1027. 

  1028.     case CB::ENGINE_OPTION_PREFER_PLUGIN_BRIDGES:

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

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

  1031.         break;

  1032. 

  1033.     case CB::ENGINE_OPTION_PREFER_UI_BRIDGES:

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

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

  1036.         break;

  1037. 

  1038.     case CB::ENGINE_OPTION_UIS_ALWAYS_ON_TOP:

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

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

  1041.         break;

  1042. 

  1043.     case CB::ENGINE_OPTION_MAX_PARAMETERS:

  1044.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1046.         break;

  1047. 

  1048.     case CB::ENGINE_OPTION_UI_BRIDGES_TIMEOUT:

  1049.         CARLA_SAFE_ASSERT_RETURN(value >= 0,);

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

  1051.         break;

  1052. 

  1053.     case CB::ENGINE_OPTION_AUDIO_NUM_PERIODS:

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

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

  1056.         break;

  1057. 

  1058.     case CB::ENGINE_OPTION_AUDIO_BUFFER_SIZE:

  1059.         CARLA_SAFE_ASSERT_RETURN(value >= 8,);

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

  1061.         break;

  1062. 

  1063.     case CB::ENGINE_OPTION_AUDIO_SAMPLE_RATE:

  1064.         CARLA_SAFE_ASSERT_RETURN(value >= 22050,);

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

  1066.         break;

  1067. 

  1068.     case CB::ENGINE_OPTION_AUDIO_DEVICE:

  1069.         CARLA_SAFE_ASSERT_RETURN(valueStr != nullptr,);

  1070. 

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

  1072.             delete[] gStandalone.engineOptions.audioDevice;

  1073. 

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

  1075.         break;

  1076. 

  1077.     case CB:: ENGINE_OPTION_NSM_INIT:

  1078.         CARLA_SAFE_ASSERT_RETURN(value != 0,);

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

  1080.         gNSM.announce(value, valueStr);

  1081.         break;

  1082. 

  1083.     case CB::ENGINE_OPTION_PATH_BINARIES:

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

  1085. 

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

  1087.             delete[] gStandalone.engineOptions.binaryDir;

  1088. 

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

  1090.         break;

  1091. 

  1092.     case CB::ENGINE_OPTION_PATH_RESOURCES:

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

  1094. 

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

  1096.             delete[] gStandalone.engineOptions.resourceDir;

  1097. 

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

  1099.         break;

  1100. 

  1101.     case CB::ENGINE_OPTION_FRONTEND_WIN_ID:

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

  1103.         const long winId(std::atol(valueStr));

  1104.         CARLA_SAFE_ASSERT_RETURN(winId >= 0,);

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

  1106.         break;

  1107.     }

  1108. 

  1109.     if (gStandalone.engine != nullptr)

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

  1111. }

  1112. #endif

  1113. 

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

  1115. {

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

  1117. 

  1118.     gStandalone.fileCallback    = func;

  1119.     gStandalone.fileCallbackPtr = ptr;

  1120. 

  1121.     if (gStandalone.engine != nullptr)

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

  1123. }

  1124. 

  1125. // -------------------------------------------------------------------------------------------------------------------

  1126. 

  1127. bool carla_load_file(const char* filename)

  1128. {

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

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

  1131. 

  1132.     if (gStandalone.engine != nullptr)

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

  1134. 

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

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

  1137.     return false;

  1138. }

  1139. 

  1140. bool carla_load_project(const char* filename)

  1141. {

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

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

  1144. 

  1145.     if (gStandalone.engine != nullptr)

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

  1147. 

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

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

  1150.     return false;

  1151. }

  1152. 

  1153. bool carla_save_project(const char* filename)

  1154. {

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

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

  1157. 

  1158.     if (gStandalone.engine != nullptr)

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

  1160. 

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

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

  1163.     return false;

  1164. }

  1165. 

  1166. #ifndef BUILD_BRIDGE

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

  1168. 

  1169. bool carla_patchbay_connect(int groupIdA, int portIdA, int groupIdB, int portIdB)

  1170. {

  1171.     carla_debug("carla_patchbay_connect(%i, %i, %i, %i)", groupIdA, portIdA, groupIdB, portIdB);

  1172. 

  1173.     if (gStandalone.engine != nullptr)

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

  1175. 

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

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

  1178.     return false;

  1179. }

  1180. 

  1181. bool carla_patchbay_disconnect(uint connectionId)

  1182. {

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

  1184. 

  1185.     if (gStandalone.engine != nullptr)

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

  1187. 

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

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

  1190.     return false;

  1191. }

  1192. 

  1193. bool carla_patchbay_refresh()

  1194. {

  1195.     carla_debug("carla_patchbay_refresh()");

  1196. 

  1197.     if (gStandalone.engine != nullptr)

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

  1199. 

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

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

  1202.     return false;

  1203. }

  1204. #endif

  1205. 

  1206. // -------------------------------------------------------------------------------------------------------------------

  1207. 

  1208. void carla_transport_play()

  1209. {

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

  1211.     carla_debug("carla_transport_play()");

  1212. 

  1213.     gStandalone.engine->transportPlay();

  1214. }

  1215. 

  1216. void carla_transport_pause()

  1217. {

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

  1219.     carla_debug("carla_transport_pause()");

  1220. 

  1221.     gStandalone.engine->transportPause();

  1222. }

  1223. 

  1224. void carla_transport_relocate(uint64_t frame)

  1225. {

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

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

  1228. 

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

  1230. }

  1231. 

  1232. uint64_t carla_get_current_transport_frame()

  1233. {

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

  1235. 

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

  1237.     return timeInfo.frame;

  1238. }

  1239. 

  1240. const CarlaTransportInfo* carla_get_transport_info()

  1241. {

  1242.     static CarlaTransportInfo retInfo;

  1243. 

  1244.     // reset

  1245.     retInfo.playing = false;

  1246.     retInfo.frame   = 0;

  1247.     retInfo.bar     = 0;

  1248.     retInfo.beat    = 0;

  1249.     retInfo.tick    = 0;

  1250.     retInfo.bpm     = 0.0;

  1251. 

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

  1253. 

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

  1255. 

  1256.     retInfo.playing = timeInfo.playing;

  1257.     retInfo.frame   = timeInfo.frame;

  1258. 

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

  1260.     {

  1261.         retInfo.bar  = timeInfo.bbt.bar;

  1262.         retInfo.beat = timeInfo.bbt.beat;

  1263.         retInfo.tick = timeInfo.bbt.tick;

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

  1265.     }

  1266. 

  1267.     return &retInfo;

  1268. }

  1269. 

  1270. // -------------------------------------------------------------------------------------------------------------------

  1271. 

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

  1273. {

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

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

  1276. 

  1277.     if (gStandalone.engine != nullptr)

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

  1279. 

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

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

  1282.     return false;

  1283. }

  1284. 

  1285. bool carla_remove_plugin(uint pluginId)

  1286. {

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

  1288. 

  1289.     if (gStandalone.engine != nullptr)

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

  1291. 

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

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

  1294.     return false;

  1295. }

  1296. 

  1297. bool carla_remove_all_plugins()

  1298. {

  1299.     carla_debug("carla_remove_all_plugins()");

  1300. 

  1301.     if (gStandalone.engine != nullptr)

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

  1303. 

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

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

  1306.     return false;

  1307. }

  1308. 

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

  1310. {

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

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

  1313. 

  1314.     if (gStandalone.engine != nullptr)

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

  1316. 

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

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

  1319.     return nullptr;

  1320. }

  1321. 

  1322. bool carla_clone_plugin(uint pluginId)

  1323. {

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

  1325. 

  1326.     if (gStandalone.engine != nullptr)

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

  1328. 

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

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

  1331.     return false;

  1332. }

  1333. 

  1334. bool carla_replace_plugin(uint pluginId)

  1335. {

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

  1337. 

  1338.     if (gStandalone.engine != nullptr)

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

  1340. 

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

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

  1343.     return false;

  1344. }

  1345. 

  1346. bool carla_switch_plugins(uint pluginIdA, uint pluginIdB)

  1347. {

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

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

  1350. 

  1351.     if (gStandalone.engine != nullptr)

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

  1353. 

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

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

  1356.     return false;

  1357. }

  1358. 

  1359. // -------------------------------------------------------------------------------------------------------------------

  1360. 

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

  1362. {

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

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

  1365. 

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

  1367.     {

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

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

  1370.         return false;

  1371.     }

  1372. 

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

  1374.         return plugin->loadStateFromFile(filename);

  1375. 

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

  1377.     return false;

  1378. }

  1379. 

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

  1381. {

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

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

  1384. 

  1385.     if (gStandalone.engine == nullptr)

  1386.     {

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

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

  1389.         return false;

  1390.     }

  1391. 

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

  1393. 

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

  1395.         return plugin->saveStateToFile(filename);

  1396. 

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

  1398.     return false;

  1399. }

  1400. 

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

  1402. 

  1403. const CarlaPluginInfo* carla_get_plugin_info(uint pluginId)

  1404. {

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

  1406. 

  1407.     static CarlaPluginInfo info;

  1408. 

  1409.     // reset

  1410.     info.type             = CB::PLUGIN_NONE;

  1411.     info.category         = CB::PLUGIN_CATEGORY_NONE;

  1412.     info.hints            = 0x0;

  1413.     info.optionsAvailable = 0x0;

  1414.     info.optionsEnabled   = 0x0;

  1415.     info.filename         = gNullCharPtr;

  1416.     info.name             = gNullCharPtr;

  1417.     info.iconName         = gNullCharPtr;

  1418.     info.uniqueId         = 0;

  1419. 

  1420.     // cleanup

  1421.     if (info.label != gNullCharPtr)

  1422.     {

  1423.         delete[] info.label;

  1424.         info.label = gNullCharPtr;

  1425.     }

  1426. 

  1427.     if (info.maker != gNullCharPtr)

  1428.     {

  1429.         delete[] info.maker;

  1430.         info.maker = gNullCharPtr;

  1431.     }

  1432. 

  1433.     if (info.copyright != gNullCharPtr)

  1434.     {

  1435.         delete[] info.copyright;

  1436.         info.copyright = gNullCharPtr;

  1437.     }

  1438. 

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

  1440. 

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

  1442.     {

  1443.         char strBufLabel[STR_MAX+1];

  1444.         char strBufMaker[STR_MAX+1];

  1445.         char strBufCopyright[STR_MAX+1];

  1446. 

  1447.         carla_zeroChar(strBufLabel, STR_MAX+1);

  1448.         carla_zeroChar(strBufMaker, STR_MAX+1);

  1449.         carla_zeroChar(strBufCopyright, STR_MAX+1);

  1450. 

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

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

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

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

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

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

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

  1458. 

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

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

  1461. 

  1462.         plugin->getLabel(strBufLabel);

  1463.         info.label = carla_strdup(strBufLabel);

  1464. 

  1465.         plugin->getMaker(strBufMaker);

  1466.         info.maker = carla_strdup(strBufMaker);

  1467. 

  1468.         plugin->getCopyright(strBufCopyright);

  1469.         info.copyright = carla_strdup(strBufCopyright);

  1470. 

  1471.         checkStringPtr(info.filename);

  1472.         checkStringPtr(info.name);

  1473.         checkStringPtr(info.iconName);

  1474. 

  1475.         return &info;

  1476.     }

  1477. 

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

  1479.     return &info;

  1480. }

  1481. 

  1482. const CarlaPortCountInfo* carla_get_audio_port_count_info(uint pluginId)

  1483. {

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

  1485. 

  1486.     static CarlaPortCountInfo info;

  1487. 

  1488.     // reset

  1489.     info.ins   = 0;

  1490.     info.outs  = 0;

  1491. 

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

  1493. 

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

  1495.     {

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

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

  1498.         return &info;

  1499.     }

  1500. 

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

  1502.     return &info;

  1503. }

  1504. 

  1505. const CarlaPortCountInfo* carla_get_midi_port_count_info(uint pluginId)

  1506. {

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

  1508. 

  1509.     static CarlaPortCountInfo info;

  1510. 

  1511.     // reset

  1512.     info.ins   = 0;

  1513.     info.outs  = 0;

  1514. 

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

  1516. 

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

  1518.     {

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

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

  1521.         return &info;

  1522.     }

  1523. 

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

  1525.     return &info;

  1526. }

  1527. 

  1528. const CarlaPortCountInfo* carla_get_parameter_count_info(uint pluginId)

  1529. {

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

  1531. 

  1532.     static CarlaPortCountInfo info;

  1533. 

  1534.     // reset

  1535.     info.ins   = 0;

  1536.     info.outs  = 0;

  1537. 

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

  1539. 

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

  1541.     {

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

  1543.         return &info;

  1544.     }

  1545. 

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

  1547.     return &info;

  1548. }

  1549. 

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

  1551. {

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

  1553. 

  1554.     static CarlaParameterInfo info;

  1555. 

  1556.     // reset

  1557.     info.scalePointCount = 0;

  1558. 

  1559.     // cleanup

  1560.     if (info.name != gNullCharPtr)

  1561.     {

  1562.         delete[] info.name;

  1563.         info.name = gNullCharPtr;

  1564.     }

  1565. 

  1566.     if (info.symbol != gNullCharPtr)

  1567.     {

  1568.         delete[] info.symbol;

  1569.         info.symbol = gNullCharPtr;

  1570.     }

  1571. 

  1572.     if (info.unit != gNullCharPtr)

  1573.     {

  1574.         delete[] info.unit;

  1575.         info.unit = gNullCharPtr;

  1576.     }

  1577. 

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

  1579. 

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

  1581.     {

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

  1583.         {

  1584.             char strBufName[STR_MAX+1];

  1585.             char strBufSymbol[STR_MAX+1];

  1586.             char strBufUnit[STR_MAX+1];

  1587. 

  1588.             carla_zeroChar(strBufName, STR_MAX+1);

  1589.             carla_zeroChar(strBufSymbol, STR_MAX+1);

  1590.             carla_zeroChar(strBufUnit, STR_MAX+1);

  1591. 

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

  1593. 

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

  1595.             info.name = carla_strdup(strBufName);

  1596. 

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

  1598.             info.symbol = carla_strdup(strBufSymbol);

  1599. 

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

  1601.             info.unit = carla_strdup(strBufUnit);

  1602.         }

  1603.         else

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

  1605. 

  1606.         return &info;

  1607.     }

  1608. 

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

  1610.     return &info;

  1611. }

  1612. 

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

  1614. {

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

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

  1617. 

  1618.     static CarlaScalePointInfo info;

  1619. 

  1620.     // reset

  1621.     info.value = 0.0f;

  1622. 

  1623.     // cleanup

  1624.     if (info.label != gNullCharPtr)

  1625.     {

  1626.         delete[] info.label;

  1627.         info.label = gNullCharPtr;

  1628.     }

  1629. 

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

  1631. 

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

  1633.     {

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

  1635.         {

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

  1637.             {

  1638.                 char strBufLabel[STR_MAX+1];

  1639.                 carla_zeroChar(strBufLabel, STR_MAX+1);

  1640. 

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

  1642. 

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

  1644.                 info.label = carla_strdup(strBufLabel);

  1645.             }

  1646.             else

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

  1648.         }

  1649.         else

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

  1651. 

  1652.         return &info;

  1653.     }

  1654. 

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

  1656.     return &info;

  1657. }

  1658. 

  1659. // -------------------------------------------------------------------------------------------------------------------

  1660. 

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

  1662. {

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

  1664. 

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

  1666. 

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

  1668. 

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

  1670.     {

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

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

  1673. 

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

  1675.         return &fallbackParameterData;

  1676.     }

  1677. 

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

  1679.     return &fallbackParameterData;

  1680. }

  1681. 

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

  1683. {

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

  1685. 

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

  1687. 

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

  1689. 

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

  1691.     {

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

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

  1694. 

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

  1696.         return &fallbackParamRanges;

  1697.     }

  1698. 

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

  1700.     return &fallbackParamRanges;

  1701. }

  1702. 

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

  1704. {

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

  1706. 

  1707.     static MidiProgramData midiProgData;

  1708. 

  1709.     // reset

  1710.     midiProgData.bank    = 0;

  1711.     midiProgData.program = 0;

  1712.     midiProgData.name    = gNullCharPtr;

  1713. 

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

  1715. 

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

  1717.     {

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

  1719.         {

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

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

  1722.             checkStringPtr(midiProgData.name);

  1723.             return &midiProgData;

  1724.         }

  1725. 

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

  1727.         return &midiProgData;

  1728.     }

  1729. 

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

  1731.     return &midiProgData;

  1732. }

  1733. 

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

  1735. {

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

  1737. 

  1738.     static CustomData customData;

  1739. 

  1740.     // reset

  1741.     customData.type  = gNullCharPtr;

  1742.     customData.key   = gNullCharPtr;

  1743.     customData.value = gNullCharPtr;

  1744. 

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

  1746. 

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

  1748.     {

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

  1750.         {

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

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

  1753.             checkStringPtr(customData.type);

  1754.             checkStringPtr(customData.key);

  1755.             checkStringPtr(customData.value);

  1756.             return &customData;

  1757.         }

  1758. 

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

  1760.         return &customData;

  1761.     }

  1762. 

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

  1764.     return &customData;

  1765. }

  1766. 

  1767. const char* carla_get_chunk_data(uint pluginId)

  1768. {

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

  1770. 

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

  1772. 

  1773.     static CarlaString chunkData;

  1774. 

  1775.     // cleanup

  1776.     chunkData.clear();

  1777. 

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

  1779.     {

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

  1781.         {

  1782.             void* data = nullptr;

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

  1784. 

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

  1786.             {

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

  1788. 

  1789.                 return chunkData;

  1790.             }

  1791.             else

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

  1793.         }

  1794.         else

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

  1796. 

  1797.         return nullptr;

  1798.     }

  1799. 

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

  1801.     return nullptr;

  1802. }

  1803. 

  1804. // -------------------------------------------------------------------------------------------------------------------

  1805. 

  1806. uint32_t carla_get_parameter_count(uint pluginId)

  1807. {

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

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

  1810. 

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

  1812.         return plugin->getParameterCount();

  1813. 

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

  1815.     return 0;

  1816. }

  1817. 

  1818. uint32_t carla_get_program_count(uint pluginId)

  1819. {

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

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

  1822. 

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

  1824.         return plugin->getProgramCount();

  1825. 

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

  1827.     return 0;

  1828. }

  1829. 

  1830. uint32_t carla_get_midi_program_count(uint pluginId)

  1831. {

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

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

  1834. 

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

  1836.         return plugin->getMidiProgramCount();

  1837. 

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

  1839.     return 0;

  1840. }

  1841. 

  1842. uint32_t carla_get_custom_data_count(uint pluginId)

  1843. {

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

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

  1846. 

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

  1848.         return plugin->getCustomDataCount();

  1849. 

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

  1851.     return 0;

  1852. }

  1853. 

  1854. // -------------------------------------------------------------------------------------------------------------------

  1855. 

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

  1857. {

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

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

  1860. 

  1861.     static char textBuf[STR_MAX+1];

  1862. 

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

  1864.     {

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

  1866.         {

  1867.             carla_zeroChar(textBuf, STR_MAX+1);

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

  1869.             return textBuf;

  1870.         }

  1871. 

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

  1873.         return nullptr;

  1874.     }

  1875. 

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

  1877.     return nullptr;

  1878. }

  1879. 

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

  1881. {

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

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

  1884. 

  1885.     static char programName[STR_MAX+1];

  1886. 

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

  1888.     {

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

  1890.         {

  1891.             carla_zeroChar(programName, STR_MAX+1);

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

  1893.             return programName;

  1894.         }

  1895. 

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

  1897.         return nullptr;

  1898.     }

  1899. 

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

  1901.     return nullptr;

  1902. }

  1903. 

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

  1905. {

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

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

  1908. 

  1909.     static char midiProgramName[STR_MAX+1];

  1910. 

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

  1912.     {

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

  1914.         {

  1915.             carla_zeroChar(midiProgramName, STR_MAX+1);

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

  1917.             return midiProgramName;

  1918.         }

  1919. 

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

  1921.         return nullptr;

  1922.     }

  1923. 

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

  1925.     return nullptr;

  1926. }

  1927. 

  1928. const char* carla_get_real_plugin_name(uint pluginId)

  1929. {

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

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

  1932. 

  1933.     static char realPluginName[STR_MAX+1];

  1934. 

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

  1936.     {

  1937.         carla_zeroChar(realPluginName, STR_MAX+1);

  1938.         plugin->getRealName(realPluginName);

  1939.         return realPluginName;

  1940.     }

  1941. 

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

  1943.     return nullptr;

  1944. }

  1945. 

  1946. // -------------------------------------------------------------------------------------------------------------------

  1947. 

  1948. int32_t carla_get_current_program_index(uint pluginId)

  1949. {

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

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

  1952. 

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

  1954.         return plugin->getCurrentProgram();

  1955. 

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

  1957.     return -1;

  1958. }

  1959. 

  1960. int32_t carla_get_current_midi_program_index(uint pluginId)

  1961. {

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

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

  1964. 

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

  1966.         return plugin->getCurrentMidiProgram();

  1967. 

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

  1969.     return -1;

  1970. }

  1971. 

  1972. // -------------------------------------------------------------------------------------------------------------------

  1973. 

  1974. float carla_get_default_parameter_value(uint pluginId, uint32_t parameterId)

  1975. {

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

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

  1978. 

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

  1980.     {

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

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

  1983. 

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

  1985.         return 0.0f;

  1986.     }

  1987. 

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

  1989.     return 0.0f;

  1990. }

  1991. 

  1992. float carla_get_current_parameter_value(uint pluginId, uint32_t parameterId)

  1993. {

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

  1995. 

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

  1997.     {

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

  1999.             return plugin->getParameterValue(parameterId);

  2000. 

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

  2002.         return 0.0f;

  2003.     }

  2004. 

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

  2006.     return 0.0f;

  2007. }

  2008. 

  2009. float carla_get_internal_parameter_value(uint pluginId, int32_t parameterId)

  2010. {

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

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

  2013. 

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

  2015.         return plugin->getInternalParameterValue(parameterId);

  2016. 

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

  2018.     return 0.0f;

  2019. }

  2020. 

  2021. // -------------------------------------------------------------------------------------------------------------------

  2022. 

  2023. float carla_get_input_peak_value(uint pluginId, bool isLeft)

  2024. {

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

  2026. 

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

  2028. }

  2029. 

  2030. float carla_get_output_peak_value(uint pluginId, bool isLeft)

  2031. {

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

  2033. 

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

  2035. }

  2036. 

  2037. // -------------------------------------------------------------------------------------------------------------------

  2038. 

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

  2040. {

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

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

  2043. 

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

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

  2046. 

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

  2048. }

  2049. 

  2050. void carla_set_active(uint pluginId, bool onOff)

  2051. {

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

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

  2054. 

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

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

  2057. 

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

  2059. }

  2060. 

  2061. #ifndef BUILD_BRIDGE

  2062. void carla_set_drywet(uint pluginId, float value)

  2063. {

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

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

  2066. 

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

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

  2069. 

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

  2071. }

  2072. 

  2073. void carla_set_volume(uint pluginId, float value)

  2074. {

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

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

  2077. 

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

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

  2080. 

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

  2082. }

  2083. 

  2084. void carla_set_balance_left(uint pluginId, float value)

  2085. {

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

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

  2088. 

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

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

  2091. 

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

  2093. }

  2094. 

  2095. void carla_set_balance_right(uint pluginId, float value)

  2096. {

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

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

  2099. 

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

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

  2102. 

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

  2104. }

  2105. 

  2106. void carla_set_panning(uint pluginId, float value)

  2107. {

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

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

  2110. 

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

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

  2113. 

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

  2115. }

  2116. #endif

  2117. 

  2118. void carla_set_ctrl_channel(uint pluginId, int8_t channel)

  2119. {

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

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

  2122. 

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

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

  2125. 

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

  2127. }

  2128. 

  2129. // -------------------------------------------------------------------------------------------------------------------

  2130. 

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

  2132. {

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

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

  2135. 

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

  2137.     {

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

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

  2140. 

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

  2142.         return;

  2143.     }

  2144. 

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

  2146. }

  2147. 

  2148. #ifndef BUILD_BRIDGE

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

  2150. {

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

  2152.     CARLA_SAFE_ASSERT_RETURN(channel >= MAX_MIDI_CHANNELS,);

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

  2154. 

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

  2156.     {

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

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

  2159. 

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

  2161.         return;

  2162.     }

  2163. 

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

  2165. }

  2166. 

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

  2168. {

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

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

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

  2172. 

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

  2174.     {

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

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

  2177. 

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

  2179.         return;

  2180.     }

  2181. 

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

  2183. }

  2184. #endif

  2185. 

  2186. // -------------------------------------------------------------------------------------------------------------------

  2187. 

  2188. void carla_set_program(uint pluginId, uint32_t programId)

  2189. {

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

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

  2192. 

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

  2194.     {

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

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

  2197. 

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

  2199.         return;

  2200.     }

  2201. 

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

  2203. }

  2204. 

  2205. void carla_set_midi_program(uint pluginId, uint32_t midiProgramId)

  2206. {

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

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

  2209. 

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

  2211.     {

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

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

  2214. 

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

  2216.         return;

  2217.     }

  2218. 

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

  2220. }

  2221. 

  2222. // -------------------------------------------------------------------------------------------------------------------

  2223. 

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

  2225. {

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

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

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

  2229.     CARLA_SAFE_ASSERT_RETURN(value != nullptr,);

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

  2231. 

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

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

  2234. 

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

  2236. }

  2237. 

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

  2239. {

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

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

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

  2243. 

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

  2245.     {

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

  2247.             return plugin->setChunkData(chunkData);

  2248. 

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

  2250.         return;

  2251.     }

  2252. 

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

  2254. }

  2255. 

  2256. // -------------------------------------------------------------------------------------------------------------------

  2257. 

  2258. void carla_prepare_for_save(uint pluginId)

  2259. {

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

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

  2262. 

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

  2264.         return plugin->prepareForSave();

  2265. 

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

  2267. }

  2268. 

  2269. void carla_reset_parameters(uint pluginId)

  2270. {

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

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

  2273. 

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

  2275.         return plugin->resetParameters();

  2276. 

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

  2278. }

  2279. 

  2280. void carla_randomize_parameters(uint pluginId)

  2281. {

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

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

  2284. 

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

  2286.         return plugin->randomizeParameters();

  2287. 

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

  2289. }

  2290. 

  2291. #ifndef BUILD_BRIDGE

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

  2293. {

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

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

  2296. 

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

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

  2299. 

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

  2301. }

  2302. #endif

  2303. 

  2304. void carla_show_custom_ui(uint pluginId, bool yesNo)

  2305. {

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

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

  2308. 

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

  2310.         return plugin->showCustomUI(yesNo);

  2311. 

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

  2313. }

  2314. 

  2315. // -------------------------------------------------------------------------------------------------------------------

  2316. 

  2317. uint32_t carla_get_buffer_size()

  2318. {

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

  2320.     carla_debug("carla_get_buffer_size()");

  2321. 

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

  2323. }

  2324. 

  2325. double carla_get_sample_rate()

  2326. {

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

  2328.     carla_debug("carla_get_sample_rate()");

  2329. 

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

  2331. }

  2332. 

  2333. // -------------------------------------------------------------------------------------------------------------------

  2334. 

  2335. const char* carla_get_last_error()

  2336. {

  2337.     carla_debug("carla_get_last_error()");

  2338. 

  2339.     if (gStandalone.engine != nullptr)

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

  2341. 

  2342.     return gStandalone.lastError;

  2343. }

  2344. 

  2345. const char* carla_get_host_osc_url_tcp()

  2346. {

  2347.     carla_debug("carla_get_host_osc_url_tcp()");

  2348. 

  2349.     if (gStandalone.engine == nullptr)

  2350.     {

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

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

  2353.         return nullptr;

  2354.     }

  2355. 

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

  2357. }

  2358. 

  2359. const char* carla_get_host_osc_url_udp()

  2360. {

  2361.     carla_debug("carla_get_host_osc_url_udp()");

  2362. 

  2363.     if (gStandalone.engine == nullptr)

  2364.     {

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

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

  2367.         return nullptr;

  2368.     }

  2369. 

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

  2371. }

  2372. 

  2373. // -------------------------------------------------------------------------------------------------------------------

  2374. 

  2375. #ifdef WANT_DSSI

  2376. # include "CarlaDssiUtils.cpp"

  2377. #endif

  2378. 

  2379. #include "CarlaStateUtils.cpp"

  2380. 

  2381. #if 0

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

  2383. {

  2384.     return 0;

  2385. }

  2386. #endif

  2387. 

  2388. // -------------------------------------------------------------------------------------------------------------------